IRCBrowse

2021/11/09

2021-11-09 00:00:06 +0100michalz(~michalz@185.246.204.61) (Remote host closed the connection)
2021-11-09 00:00:09 +0100 <dsal> yin: Sure, that's also fine as long as you don't have to ever do negative numbers. I did some algebra stuff like that in elementary school as well.
2021-11-09 00:00:29 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-11-09 00:00:54 +0100 <dsal> But the way I learned stuff, addition, multiplication, and exponentiation were just three different things. Kind of built on top of each other…
2021-11-09 00:01:06 +0100falafel(~falafel@cpe-76-168-195-162.socal.res.rr.com)
2021-11-09 00:01:14 +0100 <dsal> It wasn't until the "you can't multiply by zero!" thing came along that I realized how dumb this was.
2021-11-09 00:01:39 +0100 <yin> you can't multiply by zero?
2021-11-09 00:02:00 +0100 <monochrom> I think of that as just another flaring of freaking out at 0.
2021-11-09 00:02:16 +0100 <monochrom> Every 10 years or something, people would do that.
2021-11-09 00:02:31 +0100geekosauris just kinda fascinated at the whole discussion
2021-11-09 00:02:40 +0100 <yin> wait what are you talking about?
2021-11-09 00:03:16 +0100 <monochrom> Last time it was tax forms etc splitting "how many children do you have?" into 2 questions: "A. Do you have children? B. If yes, how many?"
2021-11-09 00:07:28 +0100 <dsal> yin: Just why I was thinking about this. Dumb thing that showed up on twitter.
2021-11-09 00:08:04 +0100 <monochrom> Hypothesis: Social collective freaking out at 0 coincides with solar flares >:)
2021-11-09 00:08:10 +0100 <dsal> > 3 <> 4 :: Sum Int
2021-11-09 00:08:12 +0100 <lambdabot> Sum {getSum = 7}
2021-11-09 00:08:19 +0100 <dsal> stimes just makes a bunch of copies and folds.
2021-11-09 00:08:24 +0100 <dsal> > stimes 3 4 :: Sum Int
2021-11-09 00:08:26 +0100 <lambdabot> Sum {getSum = 12}
2021-11-09 00:08:32 +0100 <dsal> > stimes 3 4 :: Product Int
2021-11-09 00:08:34 +0100 <lambdabot> Product {getProduct = 64}
2021-11-09 00:08:38 +0100 <dsal> > stimes 0 4 :: Sum Int
2021-11-09 00:08:40 +0100 <lambdabot> Sum {getSum = 0}
2021-11-09 00:08:43 +0100 <dsal> > stimes 0 4 :: Product Int
2021-11-09 00:08:44 +0100 <lambdabot> Product {getProduct = 1}
2021-11-09 00:08:59 +0100dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be) (Quit: WeeChat 3.3)
2021-11-09 00:09:03 +0100 <dsal> So that's 4*0 and 4^0
2021-11-09 00:10:37 +0100 <dsal> A semigroup that isn't a monoid needs a positive multiplier, but a monoid has mempty, so that's the answer at zero. Which is why *0 and ^0 work.
2021-11-09 00:10:54 +0100 <dsal> > stimes 5 f :: Expr
2021-11-09 00:10:56 +0100 <lambdabot> ((f <> f) <> f <> f) <> f
2021-11-09 00:11:40 +0100 <janus> what would be needed in the typeclass hierarchy to have it be exception safe?
2021-11-09 00:12:21 +0100 <janus> > stimes (-1) 1 :: Product Int
2021-11-09 00:12:23 +0100 <lambdabot> Product {getProduct = *Exception: Negative exponent
2021-11-09 00:13:31 +0100 <janus> i guess it would work better in haskell if negative exponentation is simply not done and people work with some kind of reciprocal operator?
2021-11-09 00:15:26 +0100 <janus> i guess it is just something haskellers have to deal with, a mathematical operation that has different constraints for different input values will need to be split into multiple operations
2021-11-09 00:15:36 +0100brainfreeze(~brainfree@2a03:1b20:4:f011::20d)
2021-11-09 00:16:20 +0100 <monochrom> Negative exponentiation makes sense when you have a group.
2021-11-09 00:18:02 +0100 <yin> speaking of it
2021-11-09 00:18:32 +0100machinedgod(~machinedg@24.105.81.50) (Ping timeout: 240 seconds)
2021-11-09 00:18:51 +0100 <yin> is it too late to fix all function types that should be Nat instead of Int?
2021-11-09 00:19:14 +0100 <janus> monochrom: right, but then that rubs a haskeller the wrong way when the mathematician has the same name for it. because according to a haskeller, different type class => different name, right ?
2021-11-09 00:19:32 +0100 <yin> and finally have a decent algebraic Nat that "collapses" as it gets evaluated?
2021-11-09 00:19:39 +0100 <monochrom> For exception-safe, you would go for "PositiveNatural -> a -> a". Note that sconcat already gets there, it's "Nonempty a -> a", so not even "[a] -> a".
2021-11-09 00:20:27 +0100 <monochrom> In the case of Num-hierarchy exponentiation, we do have ^, ^^, **
2021-11-09 00:21:01 +0100 <monochrom> Although, ^ is not exception-safe.
2021-11-09 00:21:05 +0100lavaman(~lavaman@98.38.249.169)
2021-11-09 00:21:51 +0100alzgh(~alzgh@user/alzgh) (Remote host closed the connection)
2021-11-09 00:22:11 +0100alzgh(~alzgh@user/alzgh)
2021-11-09 00:23:21 +0100 <monochrom> About Nat. Firstly, it already has a name, it's Word.
2021-11-09 00:23:26 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2021-11-09 00:24:45 +0100 <monochrom> Secondly, last time "length :: [a] -> Natural/Word" was brought up, the counterpoint was that we want to allow "length xs - k" to be negative, and even once in a while "k - length xs".
2021-11-09 00:24:47 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-11-09 00:24:47 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-11-09 00:24:47 +0100wroathe(~wroathe@user/wroathe)
2021-11-09 00:25:32 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 240 seconds)
2021-11-09 00:25:51 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2021-11-09 00:26:02 +0100 <monochrom> It participates in so many formulas that have intermediate negative answers that Int/Integer make more sense.
2021-11-09 00:26:29 +0100 <yin> sense is overrated
2021-11-09 00:27:01 +0100 <monochrom> Me, I believe in refinement types more than dependent types.
2021-11-09 00:27:11 +0100Alex_test(~al_test@94.233.240.96) (Ping timeout: 245 seconds)
2021-11-09 00:27:38 +0100 <janus> yin: the Nat/Fins in idris don't collapse in the repl and they are super slow. so maybe it is still a research problem to find out how to do that
2021-11-09 00:27:50 +0100AlexNoo_(~AlexNoo@178.34.163.82)
2021-11-09 00:27:58 +0100AlexZenon(~alzenon@94.233.240.96) (Ping timeout: 260 seconds)
2021-11-09 00:28:06 +0100 <janus> yin: so you have to remember to write `:exec <your computation>` and then it will be compiled first
2021-11-09 00:28:23 +0100AlexNoo(~AlexNoo@94.233.240.96) (Ping timeout: 256 seconds)
2021-11-09 00:28:33 +0100 <janus> a real bummer to have working code that i threw out only because i didn't know that....
2021-11-09 00:30:49 +0100 <janus> at least the difference between the compiled and the interpreted code was never that big in ghc
2021-11-09 00:31:13 +0100 <janus> but i guess it is to be expected when the type system gets all that power
2021-11-09 00:31:18 +0100cjb(~cjbayliss@user/cjb) ()
2021-11-09 00:31:48 +0100AlexZenon(~alzenon@178.34.163.82)
2021-11-09 00:31:54 +0100Alex_test(~al_test@178.34.163.82)
2021-11-09 00:33:35 +0100cjb(~cjbayliss@user/cjb)
2021-11-09 00:34:32 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-11-09 00:37:30 +0100Cajun(~Cajun@user/cajun) (Ping timeout: 256 seconds)
2021-11-09 00:43:02 +0100acidjnk_new3(~acidjnk@p200300d0c7149f82889e7e27a4cfa8d6.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2021-11-09 00:52:11 +0100srk(~sorki@user/srk) (Ping timeout: 245 seconds)
2021-11-09 00:52:21 +0100srk_(~sorki@user/srk)
2021-11-09 00:53:51 +0100falafel(~falafel@cpe-76-168-195-162.socal.res.rr.com) (Ping timeout: 250 seconds)
2021-11-09 00:55:00 +0100srk_srk
2021-11-09 00:57:33 +0100falafel(~falafel@cpe-76-168-195-162.socal.res.rr.com)
2021-11-09 01:00:59 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.3)
2021-11-09 01:02:28 +0100[Kalisto](~nico@user/kalisto/x-8968079)
2021-11-09 01:07:11 +0100emf(~emf@2620:10d:c091:480::1:6062) (Ping timeout: 245 seconds)
2021-11-09 01:07:43 +0100CiaoSen(~Jura@p200300c95730dd002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 250 seconds)
2021-11-09 01:09:15 +0100emf(~emf@2620:10d:c090:400::5:c9f2)
2021-11-09 01:09:20 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:540:e191:ad14:68ac) (Remote host closed the connection)
2021-11-09 01:11:10 +0100 <Inst> YESSS!
2021-11-09 01:11:17 +0100 <Inst> Got TinyFileDialogs isntalled via Cabal!
2021-11-09 01:15:36 +0100Inst(~Inst@2601:6c4:4080:3f80:f571:277c:e0b0:82b9) (Read error: Connection reset by peer)
2021-11-09 01:15:54 +0100Inst(~Inst@2601:6c4:4080:3f80:d8ab:2e91:63f7:db6e)
2021-11-09 01:16:54 +0100 <energizer> i feel like pattern matching is somehow the opposite of multiple dispatch. is there something i can read about their relationship?
2021-11-09 01:17:55 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:540:e191:ad14:68ac)
2021-11-09 01:19:46 +0100burnsidesLlama(~burnsides@dhcp168-022.wadham.ox.ac.uk) (Remote host closed the connection)
2021-11-09 01:19:47 +0100 <geekosaur> pattern matching is multiple dispatch on structure as opposed to type. this said, there are languages which offer pattern matching which can match on multiple types
2021-11-09 01:20:05 +0100 <geekosaur> while still matching on structure
2021-11-09 01:21:53 +0100 <geekosaur> so they're only "opposites" if you take a restrictive view of "multiple dispatch", granting that many languages do take such a restrictive view
2021-11-09 01:22:22 +0100 <energizer> i usually think of multiple dispatch as open/extensible and pattern matching as closed
2021-11-09 01:23:23 +0100 <geekosaur> this again depends on the language, I think. Haskell's pattern matching is closed
2021-11-09 01:24:30 +0100 <hpc> there's pattern matching on Either, if you squint a bit
2021-11-09 01:24:36 +0100 <geekosaur> and this is considered something of a feature, since it means the compiler will at least warn you if you refactor to add a new case to a structured value / ADT and you miss a spot where it needs to be added
2021-11-09 01:25:21 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2021-11-09 01:25:22 +0100johnjay(~pi@192.142.100.50) (Ping timeout: 260 seconds)
2021-11-09 01:25:32 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 240 seconds)
2021-11-09 01:26:38 +0100Lord_of_Life_Lord_of_Life
2021-11-09 01:27:38 +0100 <geekosaur> (and if you want extensible multiple dispatch, Haskell has typeclasses. they don't do pattern matching in the Haskell sense, though, since they dispatch on types, not values)
2021-11-09 01:28:34 +0100 <energizer> i guess i should be asking in #idris but presumably there's dependent-typeclass dispatch or something
2021-11-09 01:31:02 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2021-11-09 01:31:55 +0100unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291)
2021-11-09 01:33:42 +0100Dinya(~Dinya@77-56-51-127.dclient.hispeed.ch) (Quit: Client closed)
2021-11-09 01:33:53 +0100 <unit73e> finally managed to make aeson do what I wanted
2021-11-09 01:33:53 +0100 <sm> I think.. it was not supposed to be such an achievement.. :)
2021-11-09 01:33:54 +0100 <sm> that feeling of having beat a final boss when you get a haskell package installed..
2021-11-09 01:34:40 +0100 <unit73e> it was embarasingly simple... `decodeFileStrict f :: IO (Maybe (KM.KeyMap Sprite))`
2021-11-09 01:34:52 +0100 <unit73e> I wanted the map because the keys aren't fixed
2021-11-09 01:35:05 +0100johnjay(~pi@192.142.100.50)
2021-11-09 01:35:47 +0100 <unit73e> I had to read the source code of aeson to figure that out lol...
2021-11-09 01:39:33 +0100machinedgod(~machinedg@24.105.81.50)
2021-11-09 01:40:02 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 240 seconds)
2021-11-09 01:47:06 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-11-09 01:47:18 +0100Vajb(~Vajb@85-76-35-135-nat.elisa-mobile.fi)
2021-11-09 01:48:08 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-11-09 01:48:08 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-11-09 01:48:08 +0100wroathe(~wroathe@user/wroathe)
2021-11-09 01:48:58 +0100Guest42(~Guest42@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-11-09 01:52:32 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2021-11-09 01:53:22 +0100mark__(~a@p200300ef973db1484086f0a6a24fc4dd.dip0.t-ipconnect.de) (Quit: WeeChat 3.0.1)
2021-11-09 01:53:26 +0100kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-11-09 01:58:20 +0100mtjm(~mutantmel@2604:a880:2:d0::208b:d001) (Remote host closed the connection)
2021-11-09 01:59:20 +0100mtjm(~mutantmel@2604:a880:2:d0::208b:d001)
2021-11-09 01:59:41 +0100jkaye(~jkaye@2601:281:8300:7530:2b36:18db:1545:7097) (Ping timeout: 245 seconds)
2021-11-09 02:00:45 +0100Vajb(~Vajb@85-76-35-135-nat.elisa-mobile.fi) (Read error: Connection reset by peer)
2021-11-09 02:00:47 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:540:e191:ad14:68ac) (Remote host closed the connection)
2021-11-09 02:01:16 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-11-09 02:03:43 +0100allbery_b(~geekosaur@xmonad/geekosaur)
2021-11-09 02:03:44 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2021-11-09 02:03:47 +0100allbery_bgeekosaur
2021-11-09 02:06:07 +0100dajoer(~david@user/gvx)
2021-11-09 02:08:58 +0100 <yin> /f encding
2021-11-09 02:24:37 +0100 <danso> is there no equivalent to the TypeOperators extension for data constructors?
2021-11-09 02:25:57 +0100 <danso> meaning there's no way to define something like `data T a b = ^^ a | ?? b
2021-11-09 02:26:13 +0100 <danso> `
2021-11-09 02:26:24 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:540:e191:ad14:68ac)
2021-11-09 02:26:35 +0100 <yin> that wuld be confusing
2021-11-09 02:26:44 +0100 <yin> why would you want that?
2021-11-09 02:27:10 +0100 <danso> i can't find anything about it, but `(:)` is a type constructor operator
2021-11-09 02:28:11 +0100 <yin> it's infix
2021-11-09 02:28:51 +0100 <yin> the language supports infix data constructors starting with the character ':'
2021-11-09 02:29:26 +0100 <danso> i just realized i can do it using the () syntax ._.
2021-11-09 02:29:27 +0100 <danso> thanks anyway
2021-11-09 02:29:47 +0100Guest42(~Guest42@eth-west-pareq2-46-193-4-100.wb.wifirst.net) (Quit: Client closed)
2021-11-09 02:29:59 +0100 <danso> oh, it only allows ':'? why is that?
2021-11-09 02:31:03 +0100 <yin> convention. it's the syntax rule
2021-11-09 02:31:05 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-11-09 02:31:19 +0100Guest27(~Guest27@2601:281:d480:2ce0::93bd)
2021-11-09 02:32:22 +0100gdown(~gavin@h69-11-248-109.kndrid.broadband.dynamic.tds.net)
2021-11-09 02:36:00 +0100lbseale(~lbseale@user/ep1ctetus) (Read error: Connection reset by peer)
2021-11-09 02:40:47 +0100 <yin> think of ':' as an uppercase symbol. normal function names can't start with it
2021-11-09 02:41:27 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-11-09 02:41:28 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-11-09 02:41:28 +0100wroathe(~wroathe@user/wroathe)
2021-11-09 02:41:36 +0100 <yin> @def (:+) x y = x + y
2021-11-09 02:41:36 +0100 <lambdabot> .L.hs:164:12: error:
2021-11-09 02:41:36 +0100 <lambdabot> Ambiguous occurrence ‘x’
2021-11-09 02:41:36 +0100 <lambdabot> It could refer to
2021-11-09 02:41:39 +0100 <geekosaur> basically, pattern matches need a way to distinguish between constructors and value bindings. they use case for that, but symbols don't have case, so prefix : is treated as an "uppercase" symbol character
2021-11-09 02:41:50 +0100 <monochrom> Alphabetical data constructors begin with a capital letter. Symbolic data constructors begin with a colon. This helps the grammar to know that "f t = ..." and "x %%% y = ..." are defining functions f and (%%%), "F t = ..." and "x :% y = ..." are defining t, x, y using pattern matching.
2021-11-09 02:42:01 +0100yinsigh
2021-11-09 02:42:04 +0100 <yin> @undef
2021-11-09 02:42:04 +0100 <lambdabot> Undefined.
2021-11-09 02:42:08 +0100 <yin> @def (:+) x y = x + y
2021-11-09 02:42:09 +0100 <lambdabot> .L.hs:151:12: error:
2021-11-09 02:42:09 +0100 <lambdabot> Ambiguous occurrence ‘x’
2021-11-09 02:42:09 +0100 <lambdabot> It could refer to
2021-11-09 02:42:23 +0100 <yin> ^ what is happening here? what is this error?
2021-11-09 02:42:27 +0100 <monochrom> It could refer to x::Expr :)
2021-11-09 02:42:33 +0100 <geekosaur> ^
2021-11-09 02:43:00 +0100 <monochrom> And like I said "(:+) t u = ..." defines t and u, not (:+)
2021-11-09 02:43:03 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 250 seconds)
2021-11-09 02:43:13 +0100 <monochrom> To define (:+), please start with "data" :)
2021-11-09 02:44:48 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-11-09 02:46:07 +0100 <yin> why can't anything be not confusing?
2021-11-09 02:46:20 +0100 <monochrom> What is confusing?
2021-11-09 02:47:20 +0100 <yin> explaining things in haskell seem to be harder than understanding them sometimes. i'm just sleepy...
2021-11-09 02:48:08 +0100 <dsal> Haha. That's partially because it usually requires explaining things less precisely while still being clear.
2021-11-09 02:48:54 +0100 <monochrom> Really, it can cut both ways, depending on how you mean by "explain" and by "understand".
2021-11-09 02:49:51 +0100 <yin> monochrom: you are proving my point :D
2021-11-09 02:50:03 +0100 <monochrom> Sometimes I define "explain" to just mean "see, here are the axioms", "understand" to mean "but have you seen all theorems that follow from the axioms?". In that case, understanding is harder.
2021-11-09 02:50:56 +0100 <monochrom> Some other times, I define "understand" to mean "I've learned this stuff", "explain" to mean "now I have to teach this stuff to other people". Clearly, teaching is harder.
2021-11-09 02:52:16 +0100 <yin> too many asterisks
2021-11-09 02:52:41 +0100 <monochrom> "My God, it's full of stars"? :)
2021-11-09 02:54:27 +0100 <monochrom> Anyway, lambdabot has loaded up the simple-reflect package, which defines x to support this kind of explanations:
2021-11-09 02:54:33 +0100 <monochrom> > foldr f a [x, y, z]
2021-11-09 02:54:35 +0100 <lambdabot> f x (f y (f z a))
2021-11-09 02:55:03 +0100 <yin> i *think* i remember ghci r lambdabt quoting 2001 with the snarky remarks enabled
2021-11-09 02:55:05 +0100 <monochrom> So in fact it defines all of a to z.
2021-11-09 02:55:43 +0100 <geekosaur> ghci doesnn't. some lambdabot deatures use bsd's insults mode which includes lots of snarky remarks
2021-11-09 02:56:00 +0100 <geekosaur> *features
2021-11-09 02:56:00 +0100 <yin> that must've been it
2021-11-09 02:56:25 +0100jkaye(~jkaye@2601:281:8300:7530:1c01:b0f:3c58:2e46)
2021-11-09 02:56:29 +0100 <geekosaur> like if you query the quote db and it doesn't find a match
2021-11-09 02:56:40 +0100 <monochrom> I think @src has insults
2021-11-09 02:56:47 +0100 <monochrom> @src idd
2021-11-09 02:56:47 +0100 <lambdabot> Source not found. I've seen penguins that can type better than that.
2021-11-09 02:56:56 +0100 <yin> ^there you go
2021-11-09 02:57:10 +0100 <monochrom> Ah yeah @quote too
2021-11-09 02:57:14 +0100 <monochrom> @quote xyk
2021-11-09 02:57:14 +0100 <lambdabot> No quotes match. You untyped fool!
2021-11-09 02:58:01 +0100 <yin> it risks offending strict types
2021-11-09 02:58:43 +0100 <monochrom> Oh w00t simple-reflect also has...
2021-11-09 02:58:44 +0100 <monochrom> > foldr (⊗) z [a,b,c]
2021-11-09 02:58:46 +0100 <lambdabot> a ⊗ (b ⊗ (c ⊗ z))
2021-11-09 02:59:13 +0100 <monochrom> The complete list is at https://hackage.haskell.org/package/simple-reflect-0.3.3/docs/Debug-SimpleReflect-Vars.html
2021-11-09 03:00:08 +0100 <monochrom> Nice debate: Does it abuse Show? >:)
2021-11-09 03:00:31 +0100 <monochrom> err, s/Nice/Next/ ! Although I guess either way works.
2021-11-09 03:00:34 +0100 <danso> i appreciate the thoughtful answers, thanks :^)
2021-11-09 03:05:09 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 250 seconds)
2021-11-09 03:05:50 +0100gdown(~gavin@h69-11-248-109.kndrid.broadband.dynamic.tds.net) (Remote host closed the connection)
2021-11-09 03:10:37 +0100renzhi(~xp@2607:fa49:6500:b100::6e7f)
2021-11-09 03:16:43 +0100alzgh(~alzgh@user/alzgh) (Ping timeout: 256 seconds)
2021-11-09 03:19:02 +0100tabemann_tabemann
2021-11-09 03:22:18 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net)
2021-11-09 03:22:55 +0100vysn(~vysn@user/vysn) (Ping timeout: 250 seconds)
2021-11-09 03:23:37 +0100alzgh(alzgh@user/alzgh)
2021-11-09 03:24:41 +0100alx741(~alx741@181.196.68.101) (Quit: alx741)
2021-11-09 03:25:02 +0100shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net) (Ping timeout: 240 seconds)
2021-11-09 03:26:32 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net) (Ping timeout: 240 seconds)
2021-11-09 03:34:51 +0100Guest27(~Guest27@2601:281:d480:2ce0::93bd) (Ping timeout: 256 seconds)
2021-11-09 03:38:51 +0100zebrag(~chris@user/zebrag) (Remote host closed the connection)
2021-11-09 03:42:05 +0100zebrag(~chris@user/zebrag)
2021-11-09 03:42:33 +0100ec_(~ec@gateway/tor-sasl/ec)
2021-11-09 03:42:54 +0100ec_(~ec@gateway/tor-sasl/ec) (Client Quit)
2021-11-09 03:43:20 +0100Guest6642feetwind
2021-11-09 03:43:27 +0100feetwind(~mike@user/feetwind) (Quit: WeeChat 3.1)
2021-11-09 03:43:41 +0100feetwind(~mike@user/feetwind)
2021-11-09 03:46:08 +0100ec_(~ec@gateway/tor-sasl/ec)
2021-11-09 03:47:15 +0100ec_(~ec@gateway/tor-sasl/ec) (Client Quit)
2021-11-09 03:48:42 +0100ec_(~ec@gateway/tor-sasl/ec)
2021-11-09 03:48:43 +0100ec_(~ec@gateway/tor-sasl/ec) (Client Quit)
2021-11-09 03:50:13 +0100_koolazerkoolazer
2021-11-09 03:50:22 +0100ec_(~ec@gateway/tor-sasl/ec)
2021-11-09 03:51:06 +0100ec_ec
2021-11-09 03:52:37 +0100unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291) (Quit: Leaving)
2021-11-09 03:57:32 +0100xff0x(~xff0x@2001:1a81:5343:8e00:3d14:89a2:444a:e78d) (Ping timeout: 240 seconds)
2021-11-09 03:59:34 +0100xff0x(~xff0x@2001:1a81:536d:7000:f003:c1eb:d2a3:5377)
2021-11-09 04:01:27 +0100pop3(~pop3@user/pop3) (Remote host closed the connection)
2021-11-09 04:01:32 +0100jkaye(~jkaye@2601:281:8300:7530:1c01:b0f:3c58:2e46) (Ping timeout: 240 seconds)
2021-11-09 04:02:05 +0100pop3(~pop3@user/pop3)
2021-11-09 04:02:45 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2021-11-09 04:22:24 +0100alzgh(alzgh@user/alzgh) (Remote host closed the connection)
2021-11-09 04:22:51 +0100lavaman(~lavaman@98.38.249.169)
2021-11-09 04:27:31 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 256 seconds)
2021-11-09 04:33:23 +0100emf(~emf@2620:10d:c090:400::5:c9f2) (Ping timeout: 264 seconds)
2021-11-09 04:37:07 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2021-11-09 04:37:07 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2021-11-09 04:37:07 +0100finn_elijaFinnElija
2021-11-09 04:45:24 +0100machinedgod(~machinedg@24.105.81.50) (Ping timeout: 244 seconds)
2021-11-09 04:57:18 +0100ddb(~ddb@ipv6two.tilde.club)
2021-11-09 05:00:46 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net)
2021-11-09 05:01:42 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-11-09 05:04:36 +0100ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2021-11-09 05:04:52 +0100 <jackdk> `fmap :: Functor f => (a -> b) -> f a -> f b` is like a "one to one" map from `a` to `b`; `mapMaybe :: Filterable f => (a -> Maybe b) -> f a -> f b` maps "one to zero or one"; is there a class that does `(a -> [b]) -> f a -> f b`?
2021-11-09 05:05:29 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net) (Ping timeout: 256 seconds)
2021-11-09 05:06:00 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-11-09 05:06:15 +0100waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Quit: WeeChat 3.3)
2021-11-09 05:08:51 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-11-09 05:09:40 +0100justsomeguy(~justsomeg@user/justsomeguy)
2021-11-09 05:09:58 +0100boxscape_(~boxscape_@i577BCB42.versanet.de) (Quit: Connection closed)
2021-11-09 05:15:23 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2021-11-09 05:16:19 +0100img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2021-11-09 05:16:53 +0100renzhi(~xp@2607:fa49:6500:b100::6e7f) (Ping timeout: 250 seconds)
2021-11-09 05:17:43 +0100img(~img@user/img)
2021-11-09 05:23:09 +0100kupi(uid212005@id-212005.hampstead.irccloud.com)
2021-11-09 05:28:04 +0100 <c_wraith> jackdk: I can't imagine many instances for that. lists and multimaps, and...?
2021-11-09 05:29:35 +0100 <dsal> :t foldMap
2021-11-09 05:29:36 +0100 <lambdabot> (Foldable t, Monoid m) => (a -> m) -> t a -> m
2021-11-09 05:31:18 +0100ralu(~ralu@static.211.245.203.116.clients.your-server.de) (Ping timeout: 260 seconds)
2021-11-09 05:35:32 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-11-09 05:36:08 +0100 <awpr> an obstacle to that particular type is: how would you know how to organize the list elements into the structure of `m`? anything with more structure than a plain list would have to "make up" that extra structure
2021-11-09 05:36:44 +0100 <awpr> one natural way to address that is: change it so that the inner list is already `m b` instead. and then what you have is `Monad`
2021-11-09 05:37:59 +0100 <awpr> trees with values only at the leaves can have that kind of `Monad` instance: find a leaf value, apply a function, and graft the resulting tree in place of the leaf
2021-11-09 05:39:54 +0100 <dsal> I'm kind of guessing as to how close to that we need to get.
2021-11-09 05:40:34 +0100 <dsal> jackdk: Have you looked into recursion-schemes at all? That looks like an anamorphism.
2021-11-09 05:44:23 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (*.net *.split)
2021-11-09 05:44:23 +0100zebrag(~chris@user/zebrag) (*.net *.split)
2021-11-09 05:44:23 +0100geekosaur(~geekosaur@xmonad/geekosaur) (*.net *.split)
2021-11-09 05:44:23 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (*.net *.split)
2021-11-09 05:44:24 +0100hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com) (*.net *.split)
2021-11-09 05:44:24 +0100Codaraxis(~Codaraxis@user/codaraxis) (*.net *.split)
2021-11-09 05:44:24 +0100juhp(~juhp@128.106.188.220) (*.net *.split)
2021-11-09 05:44:24 +0100fryguybob(~fryguybob@cpe-74-67-169-145.rochester.res.rr.com) (*.net *.split)
2021-11-09 05:44:24 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net) (*.net *.split)
2021-11-09 05:44:24 +0100infinity0(~infinity0@occupy.ecodis.net) (*.net *.split)
2021-11-09 05:44:24 +0100edwtjo(~edwtjo@user/edwtjo) (*.net *.split)
2021-11-09 05:44:24 +0100niko(~niko@libera/staff/niko) (*.net *.split)
2021-11-09 05:44:24 +0100Philonous(~Philonous@user/philonous) (*.net *.split)
2021-11-09 05:44:24 +0100duckonomy(~duckonomy@177.ip-144-217-84.net) (*.net *.split)
2021-11-09 05:44:24 +0100Inoperable(~PLAYER_1@fancydata.science) (*.net *.split)
2021-11-09 05:44:24 +0100chronon(~chronon@user/chronon) (*.net *.split)
2021-11-09 05:44:24 +0100marienz(~marienz@libera/staff/marienz) (*.net *.split)
2021-11-09 05:44:24 +0100kosmikus(~kosmikus@nullzig.kosmikus.org) (*.net *.split)
2021-11-09 05:44:24 +0100edr(~edr@user/edr) (*.net *.split)
2021-11-09 05:44:24 +0100dkeohane2(~dkeohane@ec2-18-189-29-140.us-east-2.compute.amazonaws.com) (*.net *.split)
2021-11-09 05:44:24 +0100bah(~bah@l1.tel) (*.net *.split)
2021-11-09 05:44:24 +0100SethTisue__(sid14912@ilkley.irccloud.com) (*.net *.split)
2021-11-09 05:44:24 +0100angerman(sid209936@ilkley.irccloud.com) (*.net *.split)
2021-11-09 05:44:24 +0100obviyus(sid415299@user/obviyus) (*.net *.split)
2021-11-09 05:44:24 +0100tritlo(sid58727@user/tritlo) (*.net *.split)
2021-11-09 05:44:24 +0100wolfshappen(~waff@irc.furworks.de) (*.net *.split)
2021-11-09 05:44:25 +0100glguy(x@libera/staff/glguy) (*.net *.split)
2021-11-09 05:45:11 +0100mbuf(~Shakthi@136.185.69.244)
2021-11-09 05:45:11 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2021-11-09 05:45:11 +0100zebrag(~chris@user/zebrag)
2021-11-09 05:45:11 +0100geekosaur(~geekosaur@xmonad/geekosaur)
2021-11-09 05:45:11 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-11-09 05:45:11 +0100hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com)
2021-11-09 05:45:11 +0100Codaraxis(~Codaraxis@user/codaraxis)
2021-11-09 05:45:11 +0100juhp(~juhp@128.106.188.220)
2021-11-09 05:45:11 +0100fryguybob(~fryguybob@cpe-74-67-169-145.rochester.res.rr.com)
2021-11-09 05:45:11 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net)
2021-11-09 05:45:11 +0100infinity0(~infinity0@occupy.ecodis.net)
2021-11-09 05:45:11 +0100edwtjo(~edwtjo@user/edwtjo)
2021-11-09 05:45:11 +0100niko(~niko@libera/staff/niko)
2021-11-09 05:45:11 +0100Inoperable(~PLAYER_1@fancydata.science)
2021-11-09 05:45:11 +0100Philonous(~Philonous@user/philonous)
2021-11-09 05:45:11 +0100duckonomy(~duckonomy@177.ip-144-217-84.net)
2021-11-09 05:45:11 +0100chronon(~chronon@user/chronon)
2021-11-09 05:45:11 +0100edr(~edr@user/edr)
2021-11-09 05:45:11 +0100marienz(~marienz@libera/staff/marienz)
2021-11-09 05:45:11 +0100kosmikus(~kosmikus@nullzig.kosmikus.org)
2021-11-09 05:45:11 +0100dkeohane2(~dkeohane@ec2-18-189-29-140.us-east-2.compute.amazonaws.com)
2021-11-09 05:45:11 +0100bah(~bah@l1.tel)
2021-11-09 05:45:11 +0100SethTisue__(sid14912@ilkley.irccloud.com)
2021-11-09 05:45:11 +0100angerman(sid209936@ilkley.irccloud.com)
2021-11-09 05:45:11 +0100obviyus(sid415299@user/obviyus)
2021-11-09 05:45:11 +0100tritlo(sid58727@user/tritlo)
2021-11-09 05:45:11 +0100wolfshappen(~waff@irc.furworks.de)
2021-11-09 05:45:11 +0100glguy(x@libera/staff/glguy)
2021-11-09 05:47:07 +0100wolfshappen(~waff@irc.furworks.de) (Max SendQ exceeded)
2021-11-09 05:47:36 +0100wolfshappen(~waff@irc.furworks.de)
2021-11-09 05:50:56 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net)
2021-11-09 05:51:17 +0100alzgh(~alzgh@user/alzgh)
2021-11-09 05:52:46 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-11-09 05:55:01 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2021-11-09 05:55:48 +0100justsomeguy(~justsomeg@user/justsomeguy) (Quit: WeeChat 3.2)
2021-11-09 05:56:09 +0100cjb(~cjbayliss@user/cjb) (Remote host closed the connection)
2021-11-09 05:56:44 +0100angela(~angela@cpe-76-91-17-53.socal.res.rr.com)
2021-11-09 05:56:46 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-11-09 05:56:46 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-11-09 05:56:46 +0100wroathe(~wroathe@user/wroathe)
2021-11-09 06:02:03 +0100 <angela> hello
2021-11-09 06:04:52 +0100ralu(~ralu@static.211.245.203.116.clients.your-server.de)
2021-11-09 06:12:41 +0100drdo(~drdo@roach0.drdo.eu) (Quit: Ping timeout (120 seconds))
2021-11-09 06:13:20 +0100Flonk(~Flonk@ec2-52-40-29-25.us-west-2.compute.amazonaws.com) (Quit: Ping timeout (120 seconds))
2021-11-09 06:13:46 +0100Flonk(~Flonk@ec2-52-40-29-25.us-west-2.compute.amazonaws.com)
2021-11-09 06:15:26 +0100deadmarshal(~deadmarsh@95.38.112.170)
2021-11-09 06:19:13 +0100angela(~angela@cpe-76-91-17-53.socal.res.rr.com) (Quit: Client closed)
2021-11-09 06:21:01 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 250 seconds)
2021-11-09 06:36:29 +0100edr(~edr@user/edr) (Ping timeout: 244 seconds)
2021-11-09 06:37:08 +0100edr(~edr@enlo.co)
2021-11-09 06:37:08 +0100edr(~edr@enlo.co) (Changing host)
2021-11-09 06:37:08 +0100edr(~edr@user/edr)
2021-11-09 06:41:31 +0100cheater(~Username@user/cheater) (Read error: Connection reset by peer)
2021-11-09 06:44:13 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Quit: Free ZNC ~ Powered by LunarBNC: https://LunarBNC.net)
2021-11-09 06:44:58 +0100cheater(~Username@user/cheater)
2021-11-09 06:45:01 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-11-09 06:45:48 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-11-09 06:46:56 +0100haskl(~haskl@user/haskl) (Quit: Uh oh... ZNC disconnected.)
2021-11-09 06:47:11 +0100zmt00(~zmt00@user/zmt00) (Ping timeout: 245 seconds)
2021-11-09 06:47:12 +0100haskl(~haskl@user/haskl)
2021-11-09 06:48:53 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net) (Ping timeout: 244 seconds)
2021-11-09 06:48:55 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com)
2021-11-09 06:51:55 +0100haskl(~haskl@user/haskl) (Client Quit)
2021-11-09 06:52:09 +0100_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-11-09 06:55:08 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2021-11-09 06:56:15 +0100 <Inst> [exa]
2021-11-09 06:56:23 +0100 <Inst> problem solved courtesy Functional Programming Discord
2021-11-09 06:56:35 +0100 <Inst> tinyfiledialogs in Hackage does the job I was looking for
2021-11-09 06:56:48 +0100 <Inst> and it calls Windows native dialogs, even though TFD is obsolete
2021-11-09 07:01:00 +0100slowButPresent(~slowButPr@user/slowbutpresent) (Quit: leaving)
2021-11-09 07:01:29 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4)
2021-11-09 07:02:18 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-11-09 07:03:32 +0100russruss(~russruss@my.russellmcc.com) (Remote host closed the connection)
2021-11-09 07:05:06 +0100russruss(~russruss@my.russellmcc.com)
2021-11-09 07:06:07 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net)
2021-11-09 07:06:47 +0100alzgh(~alzgh@user/alzgh) (Ping timeout: 256 seconds)
2021-11-09 07:08:22 +0100 <dsal> I'm proud of my Windows ignorance.
2021-11-09 07:09:59 +0100falafel(~falafel@cpe-76-168-195-162.socal.res.rr.com) (Ping timeout: 250 seconds)
2021-11-09 07:10:32 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net) (Ping timeout: 240 seconds)
2021-11-09 07:12:00 +0100phma(phma@2001:5b0:210d:9d18:7608:a226:de13:2590)
2021-11-09 07:12:24 +0100zebrag(~chris@user/zebrag) (Remote host closed the connection)
2021-11-09 07:15:33 +0100max22-(~maxime@2a01cb08833598002528ec70f3e7e36f.ipv6.abo.wanadoo.fr) (Remote host closed the connection)
2021-11-09 07:17:27 +0100tomku(~tomku@user/tomku) (Ping timeout: 268 seconds)
2021-11-09 07:20:06 +0100 <kronicmage> Speaking of recursion schemes, is dynamic programming at all ergonomic using them? I've been experimenting for a while and have yet to find a good way
2021-11-09 07:23:32 +0100xff0x(~xff0x@2001:1a81:536d:7000:f003:c1eb:d2a3:5377) (Ping timeout: 240 seconds)
2021-11-09 07:23:48 +0100falafel(~falafel@cpe-76-168-195-162.socal.res.rr.com)
2021-11-09 07:26:05 +0100xff0x(~xff0x@2001:1a81:536d:7000:f003:c1eb:d2a3:5377)
2021-11-09 07:28:02 +0100bliminse(~bliminse@host86-185-253-43.range86-185.btcentralplus.com) (Quit: Lost terminal)
2021-11-09 07:30:44 +0100xkuru(~xkuru@user/xkuru) (Read error: Connection reset by peer)
2021-11-09 07:31:13 +0100deadmarshal(~deadmarsh@95.38.112.170) (Ping timeout: 250 seconds)
2021-11-09 07:32:20 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-11-09 07:33:45 +0100deadmarshal(~deadmarsh@95.38.112.170)
2021-11-09 07:35:06 +0100bliminse(~bliminse@host86-185-253-43.range86-185.btcentralplus.com)
2021-11-09 07:36:55 +0100echoreply(~echoreply@45.32.163.16) (Quit: WeeChat 2.8)
2021-11-09 07:38:17 +0100brainfreeze(~brainfree@2a03:1b20:4:f011::20d) (Quit: Leaving)
2021-11-09 07:46:30 +0100rkrishnan(~user@122.167.19.65)
2021-11-09 07:47:38 +0100haskl(~haskl@user/haskl)
2021-11-09 07:50:11 +0100 <Inst> dsal: guess what?
2021-11-09 07:50:18 +0100 <Inst> Chrome OS is likely going to end up murdering Windows sooner or later
2021-11-09 07:50:20 +0100 <Inst> market share went up
2021-11-09 07:50:28 +0100 <Inst> in other news, does anyone know how to get Stack to install a package globally?
2021-11-09 07:50:38 +0100 <Inst> I know this is typically not a good idea due to dependency hell
2021-11-09 07:52:01 +0100 <dsal> Inst: stack install can do that, I think, but I've not done it because why would you?
2021-11-09 07:52:17 +0100 <Inst> dsal: because I'm dumb, or rather I'm teaching someone else how to be dumb
2021-11-09 07:52:41 +0100 <Inst> and just flashing a single, small package in is likely not going to create issues
2021-11-09 07:52:52 +0100 <Inst> it's simpler than teaching them cabal before they know what recursion is
2021-11-09 07:52:56 +0100kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-11-09 07:54:20 +0100 <dsal> `stack new` is a good first step
2021-11-09 07:58:17 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4) (Remote host closed the connection)
2021-11-09 07:58:53 +0100deadmarshal(~deadmarsh@95.38.112.170) (Ping timeout: 256 seconds)
2021-11-09 08:01:26 +0100ubert(~Thunderbi@p200300ecdf4fca8de6b318fffe838f33.dip0.t-ipconnect.de)
2021-11-09 08:05:30 +0100_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-11-09 08:05:56 +0100 <Inst> creates new project
2021-11-09 08:06:19 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 250 seconds)
2021-11-09 08:06:52 +0100jinsun__jinsun
2021-11-09 08:18:18 +0100Neuromancer(~Neuromanc@user/neuromancer) (Remote host closed the connection)
2021-11-09 08:19:45 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net)
2021-11-09 08:21:40 +0100deadmarshal(~deadmarsh@95.38.112.170)
2021-11-09 08:21:56 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:e288:155f:c333:ecf4)
2021-11-09 08:24:15 +0100lavaman(~lavaman@98.38.249.169)
2021-11-09 08:28:51 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 250 seconds)
2021-11-09 08:29:26 +0100kupi(uid212005@id-212005.hampstead.irccloud.com)
2021-11-09 08:31:57 +0100jakalx(~jakalx@base.jakalx.net)
2021-11-09 08:34:24 +0100 <Inst> more realistically
2021-11-09 08:34:33 +0100 <Inst> how do i get stack to point to a different GHC folder?
2021-11-09 08:35:15 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Ping timeout: 276 seconds)
2021-11-09 08:35:24 +0100bitdex_(~bitdex@gateway/tor-sasl/bitdex)
2021-11-09 08:39:18 +0100She(~she@user/thedaemoness) (Ping timeout: 260 seconds)
2021-11-09 08:39:59 +0100She(~she@user/thedaemoness)
2021-11-09 08:47:30 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4)
2021-11-09 08:47:46 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4) (Read error: Connection reset by peer)
2021-11-09 08:48:22 +0100the_finn(uid526334@id-526334.hampstead.irccloud.com)
2021-11-09 08:53:17 +0100falafel(~falafel@cpe-76-168-195-162.socal.res.rr.com) (Ping timeout: 256 seconds)
2021-11-09 08:59:05 +0100mikoto-chan(~mikoto-ch@esm-84-240-99-143.netplaza.fi)
2021-11-09 09:00:00 +0100shriekingnoise(~shrieking@186.137.144.80) (Quit: Quit)
2021-11-09 09:02:02 +0100benin(~benin@183.82.26.68) (Ping timeout: 240 seconds)
2021-11-09 09:07:16 +0100retroid_(~retro@2e41e9c8.skybroadband.com)
2021-11-09 09:09:41 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4)
2021-11-09 09:10:17 +0100retro_(~retro@2e41e9c8.skybroadband.com) (Ping timeout: 268 seconds)
2021-11-09 09:10:32 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4) (Remote host closed the connection)
2021-11-09 09:10:48 +0100cfricke(~cfricke@user/cfricke)
2021-11-09 09:10:54 +0100juri_(~juri@178.63.35.222) (Ping timeout: 268 seconds)
2021-11-09 09:11:25 +0100juri_(~juri@178.63.35.222)
2021-11-09 09:12:12 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2021-11-09 09:13:25 +0100kuribas(~user@ptr-25vy0i9fqz6dux8z18z.18120a2.ip6.access.telenet.be)
2021-11-09 09:14:02 +0100benin(~benin@106.198.84.11)
2021-11-09 09:14:05 +0100 <kuribas> There is no way to make a formal specification, and proof that the implementation is conform it, without fancy types or dependent types, right?
2021-11-09 09:14:07 +0100max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr)
2021-11-09 09:14:10 +0100 <kuribas> like Servant for example.
2021-11-09 09:19:05 +0100CiaoSen(~Jura@p200300c95730dd002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2021-11-09 09:21:32 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 240 seconds)
2021-11-09 09:21:54 +0100 <energizer> is there a word for taking a complicated type describing a collection of values with various properties and dumbing down the type into "list of float"?
2021-11-09 09:22:21 +0100 <lortabac> kuribas: maybe an alternative would be to keep the types of the implementation simple and prove correctness extrinsically with something like Liquid Haskell
2021-11-09 09:22:21 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2021-11-09 09:22:26 +0100 <energizer> (or some other dumb type)
2021-11-09 09:22:37 +0100 <lortabac> energizer: unrefine?
2021-11-09 09:22:53 +0100 <dminuoso> kuribas: The closest thing I know of is coq + program extraction.
2021-11-09 09:22:56 +0100 <kuribas> energizer: evaluate? calculate?
2021-11-09 09:23:26 +0100 <kuribas> lortabac: define correctness.
2021-11-09 09:23:41 +0100 <dminuoso> Also dont forget tests.
2021-11-09 09:23:43 +0100 <lortabac> kuribas: you have already given the definition :P
2021-11-09 09:24:03 +0100 <lortabac> "a proof that the implementation is conform to the specification"
2021-11-09 09:24:06 +0100 <dminuoso> Especially with quichcheck or even just unit tests, these can simple serve as formal specifying properties that you can test by simply running the test suite.
2021-11-09 09:24:11 +0100 <kuribas> lortabac: I wouldn't call that "correctness". The word is so much overloaded.
2021-11-09 09:24:25 +0100 <dminuoso> Say where you specify associativity of an operator to hold, you can simply describe that with quickcheck.
2021-11-09 09:24:48 +0100 <lortabac> kuribas: ok I didn't want to type that long sentence
2021-11-09 09:25:04 +0100 <kuribas> lortabac: I prefer "conform" or "consistent".
2021-11-09 09:26:04 +0100 <kuribas> would you say that haskell (without other tools), isn't really suited for this purpose?
2021-11-09 09:26:46 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-11-09 09:26:57 +0100 <lortabac> what I wanted to say is: whatever you can prove intrinsically with fancy types, (I think) you can prove it extrinsically and move the complexity from the implementation to the proof
2021-11-09 09:27:21 +0100 <lortabac> I don't know whether this is always possible
2021-11-09 09:28:36 +0100 <lortabac> think of the various lists-with-proofs, like sized-vectors, fin etc., they all require separate implementations
2021-11-09 09:29:02 +0100dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be)
2021-11-09 09:29:17 +0100 <kuribas> lortabac: you mean like an external specification, and some test suite?
2021-11-09 09:29:25 +0100 <lortabac> whereas if you use plain lists you might be able to move the same proofs to Liquid Haskell
2021-11-09 09:30:27 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-11-09 09:31:13 +0100 <kuribas> lortabac: liquid haskell seems to me even more fancy than type level extensions.
2021-11-09 09:31:44 +0100 <kuribas> There is no garantee it will support all ghc features at any time, is there?
2021-11-09 09:31:47 +0100 <lortabac> yes, but the complexity is not in the implementation, you can delete all the proofs and the code will still work
2021-11-09 09:31:49 +0100johnny_sitar(~artur@078088015209.bialystok.vectranet.pl)
2021-11-09 09:32:33 +0100 <lortabac> whereas if you use for ex. Vec, you are stuck with it
2021-11-09 09:33:02 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 240 seconds)
2021-11-09 09:33:03 +0100lavaman(~lavaman@98.38.249.169)
2021-11-09 09:33:06 +0100 <kuribas> I see your point. I think I'd prefer tests or property tests in that case, as dminuoso suggested.
2021-11-09 09:33:20 +0100 <kuribas> There are no really "proof", but can be close to proofs.
2021-11-09 09:33:24 +0100chele(~chele@user/chele)
2021-11-09 09:33:39 +0100 <lortabac> fair point, tests are probably the best thing we have at the moment
2021-11-09 09:33:57 +0100 <kuribas> I guess I underestimate the usefulness of tests which can keep the code simple.
2021-11-09 09:35:11 +0100vysn(~vysn@user/vysn)
2021-11-09 09:36:06 +0100 <kuribas> And garantee consistency at the same time.
2021-11-09 09:37:36 +0100acidjnk_new3(~acidjnk@p200300d0c7149f82889e7e27a4cfa8d6.dip0.t-ipconnect.de)
2021-11-09 09:38:16 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-11-09 09:38:58 +0100 <lortabac> regarding Liquid Haskell, IIRC it doesn't really care about the various GHC features since it works on Core (memories from Zurihac ~2018, so I might be wrong)
2021-11-09 09:39:14 +0100 <kuribas> Does core retain types?
2021-11-09 09:39:53 +0100 <lortabac> yes, Core is typed
2021-11-09 09:41:12 +0100michalz(~michalz@185.246.204.61)
2021-11-09 09:42:01 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-11-09 09:43:40 +0100benin(~benin@106.198.84.11) (Read error: Connection reset by peer)
2021-11-09 09:44:32 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 240 seconds)
2021-11-09 09:45:29 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-11-09 09:45:42 +0100benin(~benin@183.82.26.68)
2021-11-09 09:52:00 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2021-11-09 09:52:16 +0100chomwitt(~chomwitt@2a02:587:dc0f:7c00:12c3:7bff:fe6d:d374)
2021-11-09 09:54:31 +0100mc47(~mc47@xmonad/TheMC47)
2021-11-09 09:54:51 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:540:e191:ad14:68ac) (Remote host closed the connection)
2021-11-09 09:58:02 +0100deadmarshal(~deadmarsh@95.38.112.170) (Ping timeout: 240 seconds)
2021-11-09 10:00:32 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2021-11-09 10:00:50 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4)
2021-11-09 10:06:21 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 250 seconds)
2021-11-09 10:09:14 +0100jumper149(~jumper149@80.240.31.34)
2021-11-09 10:12:31 +0100drdo(~drdo@roach0.drdo.eu)
2021-11-09 10:16:35 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-11-09 10:17:43 +0100allbery_b(~geekosaur@xmonad/geekosaur)
2021-11-09 10:17:43 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2021-11-09 10:17:46 +0100allbery_bgeekosaur
2021-11-09 10:18:05 +0100__monty__(~toonn@user/toonn)
2021-11-09 10:19:21 +0100gehmehgeh(~user@user/gehmehgeh)
2021-11-09 10:19:46 +0100gehmehgeh(~user@user/gehmehgeh) (Client Quit)
2021-11-09 10:25:32 +0100johnny_sitar(~artur@078088015209.bialystok.vectranet.pl) (Ping timeout: 240 seconds)
2021-11-09 10:28:45 +0100nuh^(~nuh@h50.174.139.63.static.ip.windstream.net)
2021-11-09 10:29:14 +0100deadmarshal(~deadmarsh@95.38.112.170)
2021-11-09 10:31:24 +0100 <DigitalKiwi> cc. Hecate; #haskell-offtopic; hecate never made me a good artists CRM so i don't know all of the infos anymore :(
2021-11-09 10:31:32 +0100max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr) (Ping timeout: 240 seconds)
2021-11-09 10:34:05 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 250 seconds)
2021-11-09 10:35:22 +0100stiell(~stiell@gateway/tor-sasl/stiell) (Remote host closed the connection)
2021-11-09 10:35:46 +0100stiell(~stiell@gateway/tor-sasl/stiell)
2021-11-09 10:39:11 +0100kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-11-09 10:39:11 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4) (Remote host closed the connection)
2021-11-09 10:40:12 +0100pop3(~pop3@user/pop3) (Remote host closed the connection)
2021-11-09 10:41:23 +0100pop3(~pop3@user/pop3)
2021-11-09 10:51:00 +0100johnny_sitar(~artur@078088015209.bialystok.vectranet.pl)
2021-11-09 10:52:36 +0100gehmehgeh(~user@user/gehmehgeh)
2021-11-09 10:53:25 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net) (Ping timeout: 256 seconds)
2021-11-09 10:55:37 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:91d4:d998:64f1:2e2f)
2021-11-09 10:58:51 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-11-09 10:59:02 +0100johnny_sitar(~artur@078088015209.bialystok.vectranet.pl) (Ping timeout: 240 seconds)
2021-11-09 10:59:22 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net)
2021-11-09 11:00:23 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:91d4:d998:64f1:2e2f) (Ping timeout: 264 seconds)
2021-11-09 11:00:47 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 256 seconds)
2021-11-09 11:01:15 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-11-09 11:01:57 +0100alzgh(~alzgh@user/alzgh)
2021-11-09 11:03:31 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-11-09 11:08:32 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 240 seconds)
2021-11-09 11:12:21 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-11-09 11:13:34 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-11-09 11:14:03 +0100 <cads> hey is there any writing done on how to make haskell "read like prose", how to simplify poorly written haskell, or how to structure haskell so that it is readable for people with a fundamentally low ability to read and process math symbols?
2021-11-09 11:15:09 +0100 <cads> in the OOP world we have uncle bob and the clean coding practice, and there are even specific clean architectures that are supposed to make code readable and extensible
2021-11-09 11:15:30 +0100 <cads> is there an uncle bob of haskell?
2021-11-09 11:15:32 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-11-09 11:15:42 +0100 <dminuoso> cads: I dont believe in "clean coding practice"
2021-11-09 11:15:53 +0100 <dminuoso> It presumes that there's some universal communicatable silver bullet in how to write code.
2021-11-09 11:16:45 +0100 <dminuoso> Writing code that communicates well is one of the key skills you develop with years of expertise
2021-11-09 11:17:02 +0100CiaoSen(~Jura@p200300c95730dd002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2021-11-09 11:17:29 +0100wonko(~wjc@user/wonko)
2021-11-09 11:17:36 +0100wonko(~wjc@user/wonko) (Remote host closed the connection)
2021-11-09 11:18:19 +0100 <cads> dminuoso, that is just an excuses to not answer my question, lol
2021-11-09 11:18:34 +0100 <dminuoso> It's similar to how authors become good. They practice writing and they read what others do.
2021-11-09 11:19:42 +0100 <cads> yeah, but I can point you to a book called How to Write a Mystery which will give you a decade's head start on being a mystery writer, simply by informing you the different ways of writing mysteries, which you may not be aware of
2021-11-09 11:20:06 +0100 <dminuoso> Mmm, well Im not aware of any such books about Haskell
2021-11-09 11:20:17 +0100 <dminuoso> And given the relatively low popularity, I dont think such a specialized book that you're asking for exists.
2021-11-09 11:20:45 +0100 <cads> likewise, I would not expect a coder to spontaneously manifest a great library of OOP patterns without first reading gang of four
2021-11-09 11:20:49 +0100 <dminuoso> Refactoring poorly written code into readable code is probably highly individual based on how you perceive code and your target audience
2021-11-09 11:21:10 +0100 <dminuoso> cads: OOP patterns is something *significaly* different from communicatable code.
2021-11-09 11:21:38 +0100x6C697370(~michael@2600:1700:7c02:3180::44) (Ping timeout: 268 seconds)
2021-11-09 11:21:38 +0100 <dminuoso> GoF patterns are not grand achievements and the ideal, they are rather dirty workarounds to solve simple problems in poor languages.
2021-11-09 11:21:55 +0100 <dminuoso> They have become somewhat of a religious item
2021-11-09 11:21:58 +0100 <dminuoso> For reasons that are beyond me
2021-11-09 11:22:11 +0100 <cads> yeah, actually reading the book I am struck by how hack to solutions seem, and how applicatives can do most of this stuff nowadays
2021-11-09 11:22:21 +0100 <cads> how hacky the solution seems*
2021-11-09 11:22:29 +0100 <tromp> does anyone know if ghcup plays nice with ihp ?
2021-11-09 11:23:27 +0100 <tromp> does ihp try to install its own ghc?
2021-11-09 11:24:45 +0100 <lortabac> dminuoso: they are hacky but they are a lingua franca
2021-11-09 11:24:51 +0100 <dminuoso> cads: Consider something like "Factory pattern". What they dub a "pattern" with a lot of moving internal parts, I simply call a function. Apply it to some argument, get something back.
2021-11-09 11:24:53 +0100 <dminuoso> Done.
2021-11-09 11:25:24 +0100 <lortabac> instead of everybody reinventing their own dirty hacks, we all use the same ones and can understand each other's code better
2021-11-09 11:25:47 +0100wonko(~wjc@user/wonko)
2021-11-09 11:25:54 +0100 <lortabac> not saying is a good state of things, I'm just trying to explain why they are popular
2021-11-09 11:27:10 +0100 <cads> dminuoso, what is a factory good for?
2021-11-09 11:28:28 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Read error: Connection reset by peer)
2021-11-09 11:28:47 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-11-09 11:31:47 +0100 <energizer> https://hackage.haskell.org/packages/top what does the "Downloads" column mean? it can't be "total downloads ever" can it?
2021-11-09 11:33:51 +0100 <cads> lortabac, I get the frustration with the cult mentality around the original GoF pattern. It's 25 years old, and there is no clear successor. So folks recommending GoF are recommending what may well be a kind of dead end in software engineering.
2021-11-09 11:37:34 +0100 <dminuoso> cads: Much of it is also patterns revolving around very constrained languages
2021-11-09 11:40:07 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2021-11-09 11:43:40 +0100 <cads> dminuoso, I think there are some good modern patterns, for example, View/Viewmodel <-> Interactor <-> Respository. I think this model is only about a decade old. But it is relevant - for example, it has become the foundation for android apps.
2021-11-09 11:44:06 +0100 <dminuoso> Sure, I dont mind general architectural design styles
2021-11-09 11:44:06 +0100 <cads> and I believe lenses can accomplish basically the same thing, but I haven't seen anyone say so
2021-11-09 11:44:46 +0100 <dminuoso> energizer: Mmm, judging from the numbers it seems *roughly* to be the past 30 days
2021-11-09 11:44:52 +0100 <dminuoso> Or perhaps a 30 days average
2021-11-09 11:44:55 +0100mikoto-chan(~mikoto-ch@esm-84-240-99-143.netplaza.fi) (Quit: mikoto-chan)
2021-11-09 11:45:11 +0100 <dminuoso> No it is the past 30 days exactly
2021-11-09 11:45:14 +0100 <dminuoso> Misread
2021-11-09 11:46:38 +0100 <cads> For reference, here is uncle bob's post announcing the clean architecture https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html
2021-11-09 11:47:02 +0100 <Franciman> uncle bob is fun
2021-11-09 11:47:15 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 256 seconds)
2021-11-09 11:47:33 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-11-09 11:48:03 +0100 <cads> I don't think it's trying to be a "universal silver bullet for communicatable code" either... it just managed solve scaling problems that, if I were to solve them the naive way, would result in a totally awful an difficult to understand code
2021-11-09 11:49:28 +0100 <cads> I suppose that to gain the same kind of confidence with my solutions in haskell, I should dig into papers
2021-11-09 11:50:22 +0100 <dminuoso> cads: The only general piece of advice I have:
2021-11-09 11:50:28 +0100 <dminuoso> You cant have enough bindings.
2021-11-09 11:51:41 +0100 <dminuoso> By creating more bindings, you can provide both smaller representations, as well as various semantic abstractions
2021-11-09 11:55:32 +0100benin(~benin@183.82.26.68) (Ping timeout: 240 seconds)
2021-11-09 11:55:39 +0100 <cads> Lol, there are no writings about how to remediate stinky haskell code. Every haskell coder knows their code reeks of pure roses. And may God help you if you say otherwise!
2021-11-09 11:56:34 +0100 <dminuoso> Uh, I have written many poor lines of code.
2021-11-09 11:57:29 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:91d4:d998:64f1:2e2f)
2021-11-09 11:57:30 +0100 <cads> yeah, but do you want to clean them up?
2021-11-09 11:58:33 +0100 <cads> I will keep compiling references on haskell code smells and how to remediate them. If you think of anything, let me know!
2021-11-09 11:58:52 +0100 <dminuoso> Yes, sometimes I have the time to do it, othertimes I dont
2021-11-09 12:00:32 +0100 <cads> dminuoso, here's an example of an article claiming /descriptive variable names/ are a code smell in haskell. I think you'll enjoy it for its zaniness, and I'd be curious if you agree with the final conclusion! file:///home/m/Zotero/storage/YI3V6P9L/insufficiently-polymorphic.html
2021-11-09 12:00:35 +0100 <cads> oops
2021-11-09 12:00:52 +0100alx741(~alx741@181.196.68.101)
2021-11-09 12:00:56 +0100 <cads> https://degoes.net/articles/insufficiently-polymorphic
2021-11-09 12:01:32 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:91d4:d998:64f1:2e2f) (Ping timeout: 240 seconds)
2021-11-09 12:04:26 +0100 <dminuoso> cads: Im not really interested in discussing that article.
2021-11-09 12:05:00 +0100 <cads> what's to discuss? It's wrong, lol.
2021-11-09 12:05:13 +0100 <dminuoso> My issue with it is deeper than that
2021-11-09 12:06:27 +0100neurocyte0132889(~neurocyte@212.232.89.58)
2021-11-09 12:06:27 +0100neurocyte0132889(~neurocyte@212.232.89.58) (Changing host)
2021-11-09 12:06:27 +0100neurocyte0132889(~neurocyte@user/neurocyte)
2021-11-09 12:08:20 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-11-09 12:10:26 +0100 <dminuoso> It's just one of those many typical blog articles people put out there for publicity. It's poorly written with non-motivating example, some random claims with poor reasoning..
2021-11-09 12:11:03 +0100 <cads> yeah, I want to yell at john for the example being bullshit, but I am physically scared of him
2021-11-09 12:12:45 +0100lavaman(~lavaman@98.38.249.169)
2021-11-09 12:14:07 +0100 <cads> I feel like the article would be good if the suggested refactoring - "Extract Monomorphism" - were really desribed with enough detail
2021-11-09 12:15:55 +0100 <cads> this sort of "Problem -> Refactoring Method -> Solution" triples are really all we can hope for when learning about a code smell. Not universal principle, but a useful option in the toolbelt. I feel a dearth of that sort of support in haskell
2021-11-09 12:16:25 +0100 <cads> but I guess I should be the solution I wanna see, and use haskell more
2021-11-09 12:16:45 +0100nschoe(~quassel@178.251.84.79)
2021-11-09 12:18:02 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 240 seconds)
2021-11-09 12:18:10 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2021-11-09 12:19:06 +0100max22-(~maxime@2a01cb088335980069e80be440b085a5.ipv6.abo.wanadoo.fr)
2021-11-09 12:26:19 +0100deadmarshal(~deadmarsh@95.38.112.170) (Ping timeout: 250 seconds)
2021-11-09 12:29:01 +0100tomku(~tomku@user/tomku)
2021-11-09 12:30:34 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-11-09 12:39:17 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2021-11-09 12:40:34 +0100Inst(~Inst@2601:6c4:4080:3f80:d8ab:2e91:63f7:db6e) (Ping timeout: 268 seconds)
2021-11-09 12:46:32 +0100chomwitt(~chomwitt@2a02:587:dc0f:7c00:12c3:7bff:fe6d:d374) (Ping timeout: 240 seconds)
2021-11-09 12:47:05 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-11-09 12:54:21 +0100benin(~benin@183.82.26.68)
2021-11-09 12:55:18 +0100CiaoSen(~Jura@p200300c95730dd002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2021-11-09 12:56:14 +0100v01d4lph4(~v01d4lph4@223.190.93.72)
2021-11-09 12:56:14 +0100v01d4lph4(~v01d4lph4@223.190.93.72) (Changing host)
2021-11-09 12:56:14 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4)
2021-11-09 12:58:31 +0100Cajun(~Cajun@user/cajun)
2021-11-09 12:59:38 +0100nuh^(~nuh@h50.174.139.63.static.ip.windstream.net) (Remote host closed the connection)
2021-11-09 13:01:14 +0100 <maerwald> "Monomorphic code is much more likely to be incorrect than polymorphic code"
2021-11-09 13:01:16 +0100 <maerwald> ahahaha
2021-11-09 13:01:26 +0100 <maerwald> has he ever used lens?
2021-11-09 13:01:57 +0100 <maerwald> the gap between "yeah, it compiles" and "yeah, it actually does what I think it does"
2021-11-09 13:02:44 +0100geekosaurthinks they're reaching for "properly typed code is much more likely to be correct" and missed by quite a margin
2021-11-09 13:03:05 +0100 <geekosaur> but still this is not someone I want on my team
2021-11-09 13:03:09 +0100 <maerwald> or classes so abstract that knowing their laws gives you zero help with understanding what they *actually do* in this context
2021-11-09 13:03:59 +0100bah(~bah@l1.tel) (Ping timeout: 244 seconds)
2021-11-09 13:04:27 +0100 <lortabac> I think his claim is true if we are only talking about parametric polymorphism
2021-11-09 13:04:32 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-11-09 13:04:49 +0100 <cads> geekosaur, forget team. This is someone that you could have /as your CEO/.
2021-11-09 13:05:14 +0100 <geekosaur> that's still my team in some sense. and I'd be looking for a way out
2021-11-09 13:05:41 +0100 <cads> I would be lifting weights, because gains is the only way to earn a meathead's respect.
2021-11-09 13:06:13 +0100 <cads> once you have greater gains you can tell them the idea is ludicrous
2021-11-09 13:06:28 +0100cadssupposes that is still a toxic dynamic
2021-11-09 13:06:28 +0100 <geekosaur> not interested in a meathead's respect tbh
2021-11-09 13:07:03 +0100 <maerwald> why did this turn into ad hominem?
2021-11-09 13:07:13 +0100 <cads> sorry
2021-11-09 13:07:32 +0100 <maerwald> "Whether in OOP or FP, the effect is the same: making the code more polymorphic reduces the space of possible implementations."
2021-11-09 13:07:39 +0100 <maerwald> that's not entirely false
2021-11-09 13:08:04 +0100 <maerwald> but really hard to generalize
2021-11-09 13:08:41 +0100 <maerwald> I'm writing a backend and I want my code actual things... you can't have all polymorphic functions. You need some data in the end.
2021-11-09 13:11:50 +0100 <maerwald> "In other words, if your method only needs to know if a thing is a Shape, then don’t also require it to be a Hexagon (a subtype of Shape)."
2021-11-09 13:12:11 +0100 <maerwald> seems like there's a small truth that was simply over-marketed with clickbait
2021-11-09 13:12:52 +0100 <maerwald> your fairly standard blog post
2021-11-09 13:13:01 +0100johnny_sitar(~artur@078088015209.bialystok.vectranet.pl)
2021-11-09 13:16:33 +0100AlexNoo_AlexNoo
2021-11-09 13:25:13 +0100benin(~benin@183.82.26.68) (Quit: The Lounge - https://thelounge.chat)
2021-11-09 13:25:18 +0100bontaq(~user@ool-45779fe5.dyn.optonline.net)
2021-11-09 13:25:39 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net) (Remote host closed the connection)
2021-11-09 13:29:21 +0100shriekingnoise(~shrieking@186.137.144.80)
2021-11-09 13:29:35 +0100CiaoSen(~Jura@p200300c95730dd002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 250 seconds)
2021-11-09 13:30:32 +0100CiaoSen(~Jura@p5dcc1a24.dip0.t-ipconnect.de)
2021-11-09 13:30:48 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net)
2021-11-09 13:31:21 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2021-11-09 13:31:58 +0100benin(~benin@183.82.26.68)
2021-11-09 13:32:53 +0100benin(~benin@183.82.26.68) (Client Quit)
2021-11-09 13:33:54 +0100servytor(uid525486@id-525486.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-11-09 13:35:04 +0100betelgeuse(~betelgeus@94-225-47-8.access.telenet.be)
2021-11-09 13:43:01 +0100ubert(~Thunderbi@p200300ecdf4fca8de6b318fffe838f33.dip0.t-ipconnect.de) (Ping timeout: 250 seconds)
2021-11-09 13:43:29 +0100chomwitt(~chomwitt@athedsl-32204.home.otenet.gr)
2021-11-09 13:46:25 +0100machinedgod(~machinedg@24.105.81.50)
2021-11-09 13:50:07 +0100mikoto-chan(~mikoto-ch@esm-84-240-99-143.netplaza.fi)
2021-11-09 13:52:32 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Ping timeout: 240 seconds)
2021-11-09 13:53:02 +0100chomwitt(~chomwitt@athedsl-32204.home.otenet.gr) (Ping timeout: 240 seconds)
2021-11-09 13:56:44 +0100deadmarshal(~deadmarsh@95.38.112.170)
2021-11-09 13:59:02 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:91d4:d998:64f1:2e2f)
2021-11-09 13:59:02 +0100ubert(~Thunderbi@ip5b405828.dynamic.kabel-deutschland.de)
2021-11-09 13:59:25 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2021-11-09 14:01:27 +0100enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7)
2021-11-09 14:03:26 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:91d4:d998:64f1:2e2f) (Ping timeout: 245 seconds)
2021-11-09 14:03:49 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk) (Remote host closed the connection)
2021-11-09 14:04:02 +0100max22-(~maxime@2a01cb088335980069e80be440b085a5.ipv6.abo.wanadoo.fr) (Ping timeout: 240 seconds)
2021-11-09 14:10:47 +0100chomwitt(~chomwitt@2a02:587:dc0f:7c00:12c3:7bff:fe6d:d374)
2021-11-09 14:13:02 +0100lavaman(~lavaman@98.38.249.169)
2021-11-09 14:17:15 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 250 seconds)
2021-11-09 14:17:33 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4) (Remote host closed the connection)
2021-11-09 14:21:12 +0100_xor(~xor@72.49.199.147) (Quit: brb)
2021-11-09 14:24:24 +0100favonia(~favonia@user/favonia)
2021-11-09 14:27:30 +0100jumper149(~jumper149@80.240.31.34) (Quit: WeeChat 3.3)
2021-11-09 14:27:35 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2021-11-09 14:27:55 +0100Sgeo(~Sgeo@user/sgeo)
2021-11-09 14:28:04 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2021-11-09 14:30:05 +0100favonia(~favonia@user/favonia) (Ping timeout: 264 seconds)
2021-11-09 14:31:51 +0100waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-11-09 14:33:05 +0100pbrisbin(~patrick@pool-173-49-152-45.phlapa.fios.verizon.net) (Quit: WeeChat 3.3)
2021-11-09 14:38:32 +0100johnny_sitar(~artur@078088015209.bialystok.vectranet.pl) (Ping timeout: 240 seconds)
2021-11-09 14:38:53 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2021-11-09 14:39:40 +0100pbrisbin(~patrick@pool-173-49-152-45.phlapa.fios.verizon.net)
2021-11-09 14:42:28 +0100max22-(~maxime@2a01cb08833598001f1c158e8ac3c365.ipv6.abo.wanadoo.fr)
2021-11-09 14:43:02 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk) (Ping timeout: 240 seconds)
2021-11-09 14:47:08 +0100chomwitt(~chomwitt@2a02:587:dc0f:7c00:12c3:7bff:fe6d:d374) (Ping timeout: 246 seconds)
2021-11-09 14:47:29 +0100max22-(~maxime@2a01cb08833598001f1c158e8ac3c365.ipv6.abo.wanadoo.fr) (Ping timeout: 246 seconds)
2021-11-09 14:50:02 +0100CiaoSen(~Jura@p5dcc1a24.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2021-11-09 14:50:13 +0100Guest60(~Guest60@2401:4900:2182:6f84:1:2:1508:28d5)
2021-11-09 14:51:19 +0100zava(~zava@ip5f5bdf0f.dynamic.kabel-deutschland.de)
2021-11-09 14:51:25 +0100deadmarshal(~deadmarsh@95.38.112.170) (Ping timeout: 256 seconds)
2021-11-09 14:51:32 +0100 <yin> why isn't `f \x -> y` parsed as `f (\x -> y` ?
2021-11-09 14:51:49 +0100 <yin> why isn't `f \x -> y` parsed as `f (\x -> y)` ? *correction
2021-11-09 14:52:24 +0100 <geekosaur> I think it is with BlockArguments?
2021-11-09 14:52:44 +0100 <geekosaur> don't recall how it gets parsed without
2021-11-09 14:53:11 +0100 <dminuoso> It doesn't get parsed at all
2021-11-09 14:53:45 +0100 <yin> i don't see ambiguity
2021-11-09 14:53:54 +0100gaff(~gaff@49.207.215.230)
2021-11-09 14:53:55 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net)
2021-11-09 14:53:57 +0100 <dminuoso> yin: Look at the grammar difference in https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0090-block-arguments.rst
2021-11-09 14:55:14 +0100 <dminuoso> That is: https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0090-block-arguments.rst#prop…
2021-11-09 14:55:40 +0100 <yin> i see
2021-11-09 14:56:11 +0100 <yin> what a mess
2021-11-09 14:56:17 +0100_xor(~xor@72.49.199.147)
2021-11-09 14:57:30 +0100 <gaff> i have some code at https://paste.ofcode.org/DCiTkXtTH7YHPbcY97b5Bd
2021-11-09 14:58:01 +0100 <gaff> i would like to know how `readsPrec` in the code works -- it seems to be infinitely recursive
2021-11-09 14:58:15 +0100Guest60(~Guest60@2401:4900:2182:6f84:1:2:1508:28d5) (Ping timeout: 256 seconds)
2021-11-09 15:00:19 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:9800:a4d7:a74e:e38)
2021-11-09 15:01:10 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-11-09 15:02:23 +0100 <geekosaur> note that the r in each case is different because of the lambda binding
2021-11-09 15:02:46 +0100 <geekosaur> so readsPrec is polymorphically recursive and will eventually bottom out at a leaf
2021-11-09 15:02:47 +0100Farzad(~FarzadBek@178.131.31.143)
2021-11-09 15:03:14 +0100 <geekosaur> (that code is kinda unfortunate, reusing bindings like that is fairly confusing)
2021-11-09 15:03:56 +0100v01d4lph4(~v01d4lph4@223.190.93.72)
2021-11-09 15:03:56 +0100v01d4lph4(~v01d4lph4@223.190.93.72) (Changing host)
2021-11-09 15:03:56 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4)
2021-11-09 15:04:32 +0100 <geekosaur> so r is successively an entire tree node, then the left subtree, then the right subtree, the latter two captured by lambda bindings
2021-11-09 15:04:48 +0100 <gaff> geekosaur: yeah, very confusing ... what do you mean by "reusing the binding"? i didn't understand ...
2021-11-09 15:04:53 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:9800:a4d7:a74e:e38) (Ping timeout: 264 seconds)
2021-11-09 15:04:54 +0100 <yin> what's the reason for Control.Monad.State not exporting the State data constructor, and providing instead the functino state :: (s -> (a,s)) -> State s a ?
2021-11-09 15:04:57 +0100 <geekosaur> calling them all "r"
2021-11-09 15:05:07 +0100 <gaff> oh ok
2021-11-09 15:05:21 +0100waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 250 seconds)
2021-11-09 15:05:29 +0100 <geekosaur> yin, State is not a data constructor, it's an alias for StateT s Identity
2021-11-09 15:05:41 +0100v01d4lph4(~v01d4lph4@user/v01d4lph4) (Remote host closed the connection)
2021-11-09 15:06:11 +0100 <geekosaur> which can't be used to construct a new State, so we need the function state. or a bidirectional pattern binding, which I think is being considered for later releases?
2021-11-09 15:06:27 +0100 <yin> ah i see. i was outdated
2021-11-09 15:07:04 +0100ubert(~Thunderbi@ip5b405828.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2021-11-09 15:07:06 +0100 <geekosaur> yeh, the data constructor was form mtl1 days
2021-11-09 15:07:10 +0100waleee(~waleee@h-98-128-228-119.NA.cust.bahnhof.se)
2021-11-09 15:07:13 +0100 <geekosaur> *from
2021-11-09 15:09:50 +0100deadmarshal(~deadmarsh@95.38.112.170)
2021-11-09 15:09:52 +0100utk(~utk@43.241.192.170)
2021-11-09 15:09:58 +0100ubert(~Thunderbi@2a02:8109:9880:303c:ca5b:76ff:fe29:f233)
2021-11-09 15:11:40 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-11-09 15:11:43 +0100 <geekosaur> hm, actually I misspoke because they're all Tree nodes, so it's not polymorphic
2021-11-09 15:11:53 +0100 <geekosaur> they're just different nodes
2021-11-09 15:12:07 +0100 <geekosaur> it's still needlessly confusing
2021-11-09 15:12:49 +0100 <yin> they're all what now?
2021-11-09 15:13:06 +0100 <geekosaur> that was about gaff's question, not yours
2021-11-09 15:13:14 +0100 <geekosaur> sorry
2021-11-09 15:13:41 +0100mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net) (Quit: ZNC 1.8.2 - https://znc.in)
2021-11-09 15:13:58 +0100mjs2600(~mjs2600@c-24-91-3-49.hsd1.vt.comcast.net)
2021-11-09 15:15:55 +0100 <gaff> geekosaur: yeah, i was wondering about what you said about being polymorphic
2021-11-09 15:16:08 +0100 <yin> :)
2021-11-09 15:16:23 +0100 <geekosaur> there should still be a polymorphic use since there are presumably values involved somewhere, not just tree nodes
2021-11-09 15:16:32 +0100 <gaff> i think the recursion convergence happens in the application of `readParen`
2021-11-09 15:16:35 +0100 <geekosaur> but those aren't polymorphic
2021-11-09 15:17:14 +0100chomwitt(~chomwitt@athedsl-32204.home.otenet.gr)
2021-11-09 15:17:34 +0100 <gaff> my concern was -- how does `readsPrec` converge?
2021-11-09 15:18:04 +0100 <gaff> i think that happens in the code for `readParen`
2021-11-09 15:18:10 +0100 <geekosaur> each subsidiary use of readsPrec is reading a different thing, either another tree node or a value
2021-11-09 15:19:01 +0100 <gaff> it is a very confusing code -- i wouldn't write it this way if i could
2021-11-09 15:19:38 +0100 <gaff> the code for readParen is @ https://downloads.haskell.org/~ghc/8.4.2/docs/html/libraries/base-4.11.1.0/src/GHC.Read.html
2021-11-09 15:19:42 +0100 <geekosaur> outer_r = [(] left_subtree_r :^: right_subtree_r [)]
2021-11-09 15:19:49 +0100 <gaff> ok
2021-11-09 15:20:21 +0100 <geekosaur> where left_subtree_r and right_subtree_r may be another split Tree node or a Leaf with a value attached, as I read it
2021-11-09 15:20:41 +0100 <gaff> correct
2021-11-09 15:20:47 +0100 <geekosaur> the code should really have used something like t, lt,k rt to distinguish instead of calling them all r
2021-11-09 15:21:00 +0100 <geekosaur> s/lt,k/lt,/
2021-11-09 15:22:19 +0100 <geekosaur> so eventually readsPrec will bottom out at a Leaf node and invoke itself one more time to read the value (this is the polymorphic one)
2021-11-09 15:22:41 +0100deadmarshal(~deadmarsh@95.38.112.170) (Ping timeout: 250 seconds)
2021-11-09 15:23:07 +0100 <gaff> ok
2021-11-09 15:23:08 +0100 <geekosaur> of course it may not actually bottom out there, since the values may be lists or even new Trees
2021-11-09 15:23:23 +0100 <geekosaur> but eventually it will bottom out
2021-11-09 15:23:33 +0100Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi)
2021-11-09 15:23:39 +0100 <gaff> exactly, otherwise you couldn't define a Tree
2021-11-09 15:23:49 +0100 <gaff> it has to bottom out
2021-11-09 15:26:46 +0100 <geekosaur> it may be easier to follow what's going on by looking at how lists work, since it's only recursive once instead of twice
2021-11-09 15:27:03 +0100 <geekosaur> each node of a [a] is (a : [a])
2021-11-09 15:27:25 +0100 <gaff> geekosaur: yea, i know ... but this is the code given in the haskell report 2010, so i wanted to understand it
2021-11-09 15:27:28 +0100 <geekosaur> and you bottom out when the value on the right of the (:) is []
2021-11-09 15:27:29 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65)
2021-11-09 15:28:12 +0100 <gaff> also, writing a custom `readsPrec` is not that easy, i think
2021-11-09 15:28:39 +0100 <geekosaur> it's fairly mechanical, actually. just a fair amount of work, which is why we make the compiler do it for us
2021-11-09 15:28:51 +0100 <gaff> ok
2021-11-09 15:28:52 +0100 <geekosaur> deriving Read wouldn't work if it were actually hard
2021-11-09 15:29:15 +0100 <gaff> just like `Show`, you mean?
2021-11-09 15:29:53 +0100f-a(f2a@f2a.jujube.ircnow.org)
2021-11-09 15:29:55 +0100 <gaff> writing a custom showsPrec is not hard
2021-11-09 15:30:10 +0100 <geekosaur> right
2021-11-09 15:30:21 +0100 <gaff> of course, you can derive `Show` as well
2021-11-09 15:30:24 +0100 <geekosaur> readsPrec is a little more work, but not that much more
2021-11-09 15:30:29 +0100utk(~utk@43.241.192.170) (Quit: WeeChat 2.8)
2021-11-09 15:30:30 +0100 <gaff> correct
2021-11-09 15:31:04 +0100 <geekosaur> more fiddly but it's all mechanical to the point that the Report specifies how the compiler should do it (well, that the compiler should do something equivalent to it)
2021-11-09 15:31:25 +0100 <gaff> yeah ...
2021-11-09 15:31:38 +0100dmwit(~dmwit@pool-173-73-185-183.washdc.fios.verizon.net) (Ping timeout: 265 seconds)
2021-11-09 15:31:44 +0100 <f-a> when I compile a program and run it on another machine I get: «error while loading shared libraries: libffi.so.7: cannot open shared object file: No such file or directory». Is there a way to catch this error? I would like if possible to print a more friendly version for people who are less used to such errors.
2021-11-09 15:31:54 +0100 <gaff> geekosaur: how long have you been working with haskell? you seem to know a lot :)
2021-11-09 15:32:32 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65) (Ping timeout: 240 seconds)
2021-11-09 15:32:49 +0100 <geekosaur> 2007
2021-11-09 15:33:06 +0100 <gaff> wow ... that's a really long time :)
2021-11-09 15:33:40 +0100 <gaff> it's a beautiful language
2021-11-09 15:34:04 +0100johnny_sitar(~artur@078088015209.bialystok.vectranet.pl)
2021-11-09 15:34:16 +0100 <geekosaur> f-a, that's output by the shared object loader before your program even runs. there are some environment variables you can set to control what the loader does (see ld.so(8) on linux) but afaik the only way to catch them is a wrapper script
2021-11-09 15:34:27 +0100 <gaff> and the people in it, unlike some of the other places, really come to haskell because of its beauty ... they just love it ... and i like that
2021-11-09 15:35:25 +0100 <f-a> argh, that is less than optimal geekosaur (but better than nothing, I guess)
2021-11-09 15:35:37 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-11-09 15:35:43 +0100 <geekosaur> (I'm oversimplifying a little bit, your program uses ld.so as its "interpreter", but no code you write can intercept what ld.so does)
2021-11-09 15:35:53 +0100 <gaff> geekosaur: thanks a bunch. i will look into the code more with your ideas ... and if there some things unclear i will get back here
2021-11-09 15:36:54 +0100gaff(~gaff@49.207.215.230) ()
2021-11-09 15:39:32 +0100nschoe(~quassel@178.251.84.79) (Ping timeout: 240 seconds)
2021-11-09 15:42:47 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2021-11-09 15:44:41 +0100wonko(~wjc@user/wonko) (Ping timeout: 256 seconds)
2021-11-09 15:45:32 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net) (Ping timeout: 240 seconds)
2021-11-09 15:45:48 +0100ByronJohnson(~bairyn@50-250-232-19-static.hfc.comcastbusiness.net)
2021-11-09 15:46:59 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk) (Ping timeout: 246 seconds)
2021-11-09 15:47:38 +0100favonia(~favonia@user/favonia)
2021-11-09 15:48:14 +0100turlando(~turlando@user/turlando) (Ping timeout: 260 seconds)
2021-11-09 15:48:51 +0100turlando(~turlando@93-42-250-112.ip89.fastwebnet.it)
2021-11-09 15:48:51 +0100turlando(~turlando@93-42-250-112.ip89.fastwebnet.it) (Changing host)
2021-11-09 15:48:51 +0100turlando(~turlando@user/turlando)
2021-11-09 15:49:33 +0100chomwitt(~chomwitt@athedsl-32204.home.otenet.gr) (Ping timeout: 250 seconds)
2021-11-09 15:53:50 +0100nschoe(~quassel@178.251.84.79)
2021-11-09 15:54:47 +0100nschoe(~quassel@178.251.84.79) (Client Quit)
2021-11-09 15:55:45 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-11-09 15:55:45 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-11-09 15:55:45 +0100wroathe(~wroathe@user/wroathe)
2021-11-09 15:57:40 +0100hololeap(~hololeap@user/hololeap) (Remote host closed the connection)
2021-11-09 15:58:11 +0100rtsn(~nstr@user/rtsn)
2021-11-09 15:58:45 +0100favonia(~favonia@user/favonia) (Quit: Leaving)
2021-11-09 15:59:07 +0100hololeap(~hololeap@user/hololeap)
2021-11-09 15:59:41 +0100gaff(~gaff@49.207.215.230)
2021-11-09 16:00:07 +0100gaff(~gaff@49.207.215.230) (Client Quit)
2021-11-09 16:05:00 +0100hpc(~juzz@ip98-169-35-13.dc.dc.cox.net) (Ping timeout: 260 seconds)
2021-11-09 16:05:20 +0100tomku[m](~tomkumozi@2001:470:69fc:105::1:2fcb)
2021-11-09 16:05:36 +0100waleee(~waleee@h-98-128-228-119.NA.cust.bahnhof.se) (Quit: WeeChat 3.3)
2021-11-09 16:05:57 +0100enoq(~enoq@2a05:1141:1f5:5600:b9c9:721a:599:bfe7) (Quit: enoq)
2021-11-09 16:06:23 +0100hpc(~juzz@ip98-169-35-13.dc.dc.cox.net)
2021-11-09 16:06:56 +0100Farzad(~FarzadBek@178.131.31.143) (Ping timeout: 246 seconds)
2021-11-09 16:08:03 +0100waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd)
2021-11-09 16:08:11 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 250 seconds)
2021-11-09 16:11:08 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 246 seconds)
2021-11-09 16:13:45 +0100jkaye(~jkaye@2601:281:8300:7530:49b1:9f67:bcbc:61f)
2021-11-09 16:14:59 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-11-09 16:15:04 +0100xkuru(~xkuru@user/xkuru)
2021-11-09 16:17:11 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65)
2021-11-09 16:21:37 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65) (Ping timeout: 250 seconds)
2021-11-09 16:22:43 +0100zmt00(~zmt00@user/zmt00)
2021-11-09 16:22:53 +0100waleee(~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 264 seconds)
2021-11-09 16:23:11 +0100chomwitt(~chomwitt@athedsl-32204.home.otenet.gr)
2021-11-09 16:23:17 +0100Xnuk(~xnuk@vultr.xnu.kr) (Remote host closed the connection)
2021-11-09 16:24:49 +0100dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be) (Quit: WeeChat 3.3)
2021-11-09 16:29:51 +0100asthasr(~asthasr@162.210.28.151)
2021-11-09 16:30:29 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net) (Remote host closed the connection)
2021-11-09 16:42:12 +0100max22-(~maxime@2a01cb0883359800c49e7f6f9540e9e4.ipv6.abo.wanadoo.fr)
2021-11-09 16:42:21 +0100 <yin> i don't like transformers
2021-11-09 16:42:36 +0100cosimone`(~user@2001:b07:ae5:db26:c24a:d20:4d91:1e20)
2021-11-09 16:42:57 +0100 <yin> /vent
2021-11-09 16:49:29 +0100 <sshine> how do you transmit electric current between circuits, then?
2021-11-09 16:50:05 +0100lavaman(~lavaman@98.38.249.169)
2021-11-09 16:50:29 +0100f-a(f2a@f2a.jujube.ircnow.org) ()
2021-11-09 16:50:36 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65)
2021-11-09 16:51:15 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Quit: Leaving)
2021-11-09 16:52:43 +0100slowButPresent(~slowButPr@user/slowbutpresent)
2021-11-09 16:52:48 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-11-09 16:54:49 +0100 <dminuoso> With a pair of cables?
2021-11-09 16:55:02 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65) (Ping timeout: 240 seconds)
2021-11-09 16:55:32 +0100CiaoSen(~Jura@p200300c95730dd002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2021-11-09 16:55:51 +0100cosimone`(~user@2001:b07:ae5:db26:c24a:d20:4d91:1e20) (Quit: ERC (IRC client for Emacs 27.1))
2021-11-09 16:56:11 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Quit: WeeChat 3.3)
2021-11-09 16:56:28 +0100cosimone(~user@2001:b07:ae5:db26:c24a:d20:4d91:1e20)
2021-11-09 16:56:39 +0100Farzad(~FarzadBek@185.131.125.102)
2021-11-09 16:58:06 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-11-09 16:58:16 +0100 <kuribas> with copper traces.
2021-11-09 16:58:46 +0100Farzad(~FarzadBek@185.131.125.102) (Client Quit)
2021-11-09 16:58:59 +0100 <dminuoso> Also, you can use capacitors to achieve the same effect!
2021-11-09 16:59:05 +0100 <dminuoso> (See capacitive power supplies)
2021-11-09 16:59:27 +0100 <kuribas> transformers provide impedance matching
2021-11-09 17:01:09 +0100 <maerwald> I also don't like them. They're clunky and have no precise semantics. You always reason about them operationally, from experience and pitfalls (e.g. MonadFail behavior in ExceptT).
2021-11-09 17:01:28 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net)
2021-11-09 17:02:47 +0100 <dsal> yin: there are lots of effect systems because everyone dislikes each of them.
2021-11-09 17:03:25 +0100 <dsal> My least favorite is "all functions are in IO" which seems to be required in every other programming language.
2021-11-09 17:03:43 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655) (Quit: WeeChat 3.3)
2021-11-09 17:04:15 +0100 <maerwald> effects systems just shift the problem to the interpreter... now you can't reason about anything, because you don't know what interpreter is run when looking at a function?
2021-11-09 17:05:07 +0100Sgeo_(~Sgeo@user/sgeo)
2021-11-09 17:05:11 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2021-11-09 17:05:50 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Quit: -)
2021-11-09 17:06:05 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net) (Ping timeout: 264 seconds)
2021-11-09 17:07:32 +0100chexum(~quassel@gateway/tor-sasl/chexum)
2021-11-09 17:08:42 +0100Guest42(~Guest42@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-11-09 17:11:43 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:e288:155f:c333:ecf4) (Quit: WeeChat 2.8)
2021-11-09 17:11:48 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2021-11-09 17:12:17 +0100deadmarshal(~deadmarsh@95.38.112.170)
2021-11-09 17:13:09 +0100 <maerwald> imagine file system effects as a DSL... even something seemingly simple as 'copyFile' or 'deleteFile' can have 10 different implementations. Differences in atomicity, error handling, recursion (cp -r) etc etc
2021-11-09 17:13:21 +0100f-a(f2a@f2a.jujube.ircnow.org)
2021-11-09 17:15:37 +0100 <dolio> "All functions are in IO" isn't even a good effect system.
2021-11-09 17:15:52 +0100 <maerwald> it's honest though
2021-11-09 17:16:39 +0100deadmarshal(~deadmarsh@95.38.112.170) (Ping timeout: 250 seconds)
2021-11-09 17:23:19 +0100lavaman(~lavaman@98.38.249.169)
2021-11-09 17:24:04 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65)
2021-11-09 17:27:56 +0100mbuf(~Shakthi@136.185.69.244) (Quit: Leaving)
2021-11-09 17:28:17 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 264 seconds)
2021-11-09 17:28:53 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65) (Ping timeout: 264 seconds)
2021-11-09 17:31:20 +0100bah(~bah@l1.tel)
2021-11-09 17:33:50 +0100bliminse(~bliminse@host86-185-253-43.range86-185.btcentralplus.com) (Quit: leaving)
2021-11-09 17:33:56 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-11-09 17:34:22 +0100 <monochrom> I am a formal methods person. I like precise semantics. But as much as I do that, I recognize that most programmers don't care.
2021-11-09 17:35:02 +0100 <dolio> The problem isn't a lack of precision.
2021-11-09 17:35:05 +0100 <monochrom> They use good-enough approximate models all the time. Not just for MonadState. For everything. For C. For jquery.
2021-11-09 17:35:11 +0100f-a(f2a@f2a.jujube.ircnow.org) ()
2021-11-09 17:36:09 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-11-09 17:36:09 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-11-09 17:36:09 +0100wroathe(~wroathe@user/wroathe)
2021-11-09 17:36:43 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2021-11-09 17:36:54 +0100 <dolio> It's the same problem as the mindset of only thinking about types as catching errors.
2021-11-09 17:37:25 +0100 <monochrom> I know how to give MonadState a precise semantics. There is already a paper doing that, to (MonadState s m) => ... alone. I know what it is missing, the usual frame problem of what happens if you have instead (MonadState s m, MonadWriter w m) => .... I know how to use the usual solutions to the frame problem to solve that. It can all be done.
2021-11-09 17:37:53 +0100 <monochrom> But I don't anticipate that users will actually value that.
2021-11-09 17:38:27 +0100 <maerwald> Well, here's the problem: not everything is precise (filesystems, networks, ...). I feel `IO` captures this pretty well, by saying "you have to apply operational reasoning right now". I wonder if we could make this distinction better somehow, but probably not
2021-11-09 17:38:27 +0100 <dolio> Monads in Haskell, and other recent effect stuff aren't just more precisely dividing up which parts of the program use some pre-canned set of effects. The 'effects' are additional ways of structuring programs.
2021-11-09 17:38:29 +0100bliminse(~bliminse@host86-185-253-43.range86-185.btcentralplus.com)
2021-11-09 17:38:38 +0100alzgh(~alzgh@user/alzgh) (Ping timeout: 256 seconds)
2021-11-09 17:39:12 +0100 <monochrom> Yeah, the types are expressing interfaces.
2021-11-09 17:40:10 +0100shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net)
2021-11-09 17:40:10 +0100dajoer(~david@user/gvx) (Quit: leaving)
2021-11-09 17:40:36 +0100 <maerwald> which is non-declarative, in a way
2021-11-09 17:41:02 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2021-11-09 17:41:35 +0100 <maerwald> The only thing my mtl constraints tell me is what functions might be used further down in the callstack. It rarely helps with figuring out what's going on though.
2021-11-09 17:42:16 +0100 <maerwald> but I have no idea how to make it better. I think there's a somewhat hard problem here though
2021-11-09 17:44:39 +0100 <yushyin> every time I switch to this channel and read a bit, it's always the same discussions :D (and often the same people too)
2021-11-09 17:44:49 +0100cheater(~Username@user/cheater) (Ping timeout: 256 seconds)
2021-11-09 17:45:12 +0100cheater(~Username@user/cheater)
2021-11-09 17:45:18 +0100 <monochrom> Don't worry, I try to give new information! Like this time. I had never said that thing before.
2021-11-09 17:45:38 +0100 <yushyin> ;)
2021-11-09 17:47:05 +0100 <monochrom> Even Haskell itself lacks a precise semantics. Not one that enjoys community consensus.
2021-11-09 17:48:00 +0100 <monochrom> Javascript has a precise semantics but programmers don't actually use it; most don't even know that it exists.
2021-11-09 17:48:31 +0100 <monochrom> And libraries. Most libraries don't have precise semantics. Any language.
2021-11-09 17:49:24 +0100 <monochrom> I want you to meditate on how programmers still have the empirical success they have now, despite this.
2021-11-09 17:52:25 +0100 <maerwald> can you propose precise semantics for a blockchain? xD
2021-11-09 17:52:33 +0100alzgh(alzgh@user/alzgh)
2021-11-09 17:53:22 +0100 <maerwald> or... dependency resolution
2021-11-09 17:53:35 +0100alzgh(alzgh@user/alzgh) (Remote host closed the connection)
2021-11-09 17:55:20 +0100jokleinn(~jokleinn@user/jokleinn)
2021-11-09 17:55:22 +0100gaff(~gaff@49.207.215.230)
2021-11-09 17:55:31 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65)
2021-11-09 17:55:34 +0100gaff(~gaff@49.207.215.230) (Client Quit)
2021-11-09 17:55:35 +0100_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-11-09 17:55:39 +0100acidjnk_new3(~acidjnk@p200300d0c7149f82889e7e27a4cfa8d6.dip0.t-ipconnect.de) (Ping timeout: 250 seconds)
2021-11-09 17:55:51 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net)
2021-11-09 17:57:23 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:9800:a4d7:a74e:e38)
2021-11-09 17:57:55 +0100lavaman(~lavaman@98.38.249.169)
2021-11-09 17:58:46 +0100lbseale(~lbseale@user/ep1ctetus)
2021-11-09 17:59:38 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65) (Ping timeout: 246 seconds)
2021-11-09 18:00:18 +0100alzgh(~alzgh@user/alzgh)
2021-11-09 18:00:32 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net) (Ping timeout: 240 seconds)
2021-11-09 18:01:03 +0100emf(~emf@2620:10d:c090:400::5:b872)
2021-11-09 18:02:09 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 250 seconds)
2021-11-09 18:02:29 +0100chomwitt(~chomwitt@athedsl-32204.home.otenet.gr) (Ping timeout: 264 seconds)
2021-11-09 18:03:32 +0100rkrishnan(~user@122.167.19.65) (Ping timeout: 240 seconds)
2021-11-09 18:03:32 +0100jokleinn(~jokleinn@user/jokleinn) (Quit: WeeChat 3.3)
2021-11-09 18:05:30 +0100servytor(uid525486@id-525486.hampstead.irccloud.com)
2021-11-09 18:05:30 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2021-11-09 18:05:58 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2021-11-09 18:06:05 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-11-09 18:08:37 +0100chomwitt(~chomwitt@2a02:587:dc0f:7c00:12c3:7bff:fe6d:d374)
2021-11-09 18:12:11 +0100img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2021-11-09 18:12:42 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.3)
2021-11-09 18:13:34 +0100img(~img@user/img)
2021-11-09 18:15:44 +0100CiaoSen(~Jura@p200300c95730dd002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 246 seconds)
2021-11-09 18:16:47 +0100Cale(~cale@cpef48e38ee8583-cm30b7d4b3fc20.cpe.net.cable.rogers.com) (Ping timeout: 260 seconds)
2021-11-09 18:20:47 +0100 <yin> yushyin: repetition is good
2021-11-09 18:21:55 +0100 <yin> and so is consistency
2021-11-09 18:23:17 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com)
2021-11-09 18:26:23 +0100mmhat(~mmh@55d4bf19.access.ecotel.net)
2021-11-09 18:29:04 +0100Skyfire(~pyon@user/pyon) (Quit: WeeChat 3.3)
2021-11-09 18:29:05 +0100waleee(~waleee@192.165.44.49)
2021-11-09 18:29:17 +0100Skyfire(~pyon@user/pyon)
2021-11-09 18:30:26 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk) (Remote host closed the connection)
2021-11-09 18:30:44 +0100ec(~ec@gateway/tor-sasl/ec)
2021-11-09 18:35:15 +0100psydurr(~psydurr@pool-141-152-27-2.rcmdva.fios.verizon.net)
2021-11-09 18:40:46 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:9800:a4d7:a74e:e38) (Remote host closed the connection)
2021-11-09 18:41:35 +0100nvmd(~nvmd@user/nvmd) (Quit: Later, nerds.)
2021-11-09 18:44:36 +0100jamestmartin(james@jtmar.me) (Quit: ZNC 1.8.2+deb2+b1 - https://znc.in)
2021-11-09 18:44:45 +0100jamestmartin(~james@jtmar.me)
2021-11-09 18:44:49 +0100 <dsal> I'm pretty annoyed by repetition. People genuinely arguing that copying and pasting stuff three times in a row is better than naming it, because, you know, if something has a name, you'd have to look it up. (then the thing is basically `fromRight` but with an error message and I'd expect anyone reading the code to just know what it did without even looking it up because there's only so much it *can* do).
2021-11-09 18:45:32 +0100 <dminuoso> Third alternative, use `replicateM_ 3 foo`
2021-11-09 18:45:53 +0100 <dminuoso> Sometimes the trick lies not in naming, but in picking the right tools.
2021-11-09 18:46:23 +0100lavaman(~lavaman@98.38.249.169)
2021-11-09 18:48:09 +0100zincy(~zincy@host86-181-60-139.range86-181.btcentralplus.com)
2021-11-09 18:51:20 +0100psydurr(~psydurr@pool-141-152-27-2.rcmdva.fios.verizon.net) (Quit: Leaving)
2021-11-09 18:52:28 +0100 <dsal> Heh. It's three different actions, but the arguments are similar. I'm in a strange world where people want to use haskell, but are deathly afraid of any abstraction.
2021-11-09 18:52:29 +0100zincy(~zincy@host86-181-60-139.range86-181.btcentralplus.com) (Ping timeout: 246 seconds)
2021-11-09 18:53:05 +0100psydurr(~psydurr@pool-141-152-27-2.rcmdva.fios.verizon.net)
2021-11-09 18:53:14 +0100jamestmartin(~james@jtmar.me) (Remote host closed the connection)
2021-11-09 18:54:08 +0100deadmarshal(~deadmarsh@95.38.112.170)
2021-11-09 18:54:10 +0100 <dsal> Now we want to copy and paste `TE.decodeUtf8With TE.lenientDecode` everywhere instead of just naming it somewhere and reusing it because something about making the decision every time or something. Except we don't, we use that one.
2021-11-09 18:55:30 +0100jamestmartin(james@2600:3c01::f03c:91ff:fefc:20b6)
2021-11-09 18:59:16 +0100 <yin> what's that asterisk doing there? https://hackage.haskell.org/package/base-4.16.0.0/docs/Control-Applicative.html#v:liftA
2021-11-09 18:59:49 +0100 <awpr> haddock markup mistake
2021-11-09 19:00:01 +0100jamestmartin(james@2600:3c01::f03c:91ff:fefc:20b6) (Client Quit)
2021-11-09 19:00:05 +0100 <dsal> liftA f a = pure f <*> a
2021-11-09 19:00:07 +0100 <awpr> supposed to be `<*>`, but it looks like it got interpreted as URL syntax
2021-11-09 19:00:10 +0100jamestmartin(~james@2600:3c01:e000:41d::1)
2021-11-09 19:00:16 +0100 <geekosaur> yeh, that's markup fail
2021-11-09 19:00:36 +0100nvmd(~nvmd@user/nvmd)
2021-11-09 19:00:46 +0100mc47(~mc47@xmonad/TheMC47)
2021-11-09 19:01:11 +0100oxytocat(~alloca@2a03:4000:f:7ca:7407:d1ff:fe34:8cd0) (Changing host)
2021-11-09 19:01:11 +0100oxytocat(~alloca@user/suppi)
2021-11-09 19:02:18 +0100nvmd(~nvmd@user/nvmd) (Client Quit)
2021-11-09 19:02:32 +0100nvmd(~nvmd@user/nvmd)
2021-11-09 19:03:22 +0100 <yin> another fail:
2021-11-09 19:03:22 +0100 <yin> • The function ‘pure’ is applied to two arguments,
2021-11-09 19:03:23 +0100 <yin> but its type ‘(a0 -> a0) -> m0 a1 -> a0 -> a0’ has only three
2021-11-09 19:03:38 +0100 <yin> *only*
2021-11-09 19:05:52 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2021-11-09 19:06:23 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f805:19de:1108:4b97)
2021-11-09 19:06:40 +0100 <maerwald> dsal: deduplication isn't abstraction
2021-11-09 19:07:13 +0100 <maerwald> sometimes, duplicating code is the right decision, because the implementations may diverge and coupling will cause bugs and confusion
2021-11-09 19:07:47 +0100 <dsal> Sure, I understand the distinction (at least to a degree, it gets fuzzy at some point).
2021-11-09 19:08:11 +0100 <maerwald> I start with duplication a lot, in fact... and after I'm done, I look at the overall code, and wonder if I can see an *actual* abstraction
2021-11-09 19:08:33 +0100 <maerwald> but it's good to make a note "TODO: maybe factor out"
2021-11-09 19:09:09 +0100econo(uid147250@user/econo)
2021-11-09 19:09:22 +0100 <maerwald> starting with the deduplication sends your code on an odd journey, sometimes
2021-11-09 19:09:28 +0100 <dsal> The larger argument has been along the lines of "code should continually march off to the right in case statements" and I'm like, "Hey, this always does the same thing in `Left` and `Nothing` cases and you only really care about the end result of all the Rights/Justs. What if we *don't* have all that stuff?
2021-11-09 19:09:36 +0100 <maerwald> introducing boolean flags to functions, for instance
2021-11-09 19:09:52 +0100 <dsal> I do tend to start writing things that are less ideal in many cases. Gets me going at least.
2021-11-09 19:10:11 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk) (Ping timeout: 250 seconds)
2021-11-09 19:11:45 +0100utk1(~utk@43.241.192.170)
2021-11-09 19:12:00 +0100utk1(~utk@43.241.192.170) ()
2021-11-09 19:12:08 +0100 <maerwald> all good projects start with "I don't know what I'm doing"
2021-11-09 19:12:22 +0100 <johnjay> maerwald: i think the assumption is you'll build a bunch of stuff on top of your code
2021-11-09 19:12:31 +0100 <johnjay> so then you can't feasibly refactor it later to remove the duplication
2021-11-09 19:12:50 +0100 <maerwald> that means there is no duplication
2021-11-09 19:13:01 +0100 <maerwald> it just started with a similar structure
2021-11-09 19:13:32 +0100utk1(~utk@43.241.192.170)
2021-11-09 19:13:36 +0100 <johnjay> well if you define x to be 1 a hundred times that's a hundred things to unite under one abstraction
2021-11-09 19:13:39 +0100 <yin> all good projects start with "i know what i'm *not* doing" i find
2021-11-09 19:14:12 +0100ec(~ec@gateway/tor-sasl/ec) (Ping timeout: 276 seconds)
2021-11-09 19:14:14 +0100 <maerwald> johnjay: I can't follow this example
2021-11-09 19:14:41 +0100 <maerwald> I'm pretty sure you'll find a couple of hundred variables in big codebases (maybe even GHC RTS) that are just 1
2021-11-09 19:14:50 +0100 <dsal> The argument here is the opposite. It's something along the lines of "If we make functions for things we do, we won't be able to understand what we're doing without understanding those functions!"
2021-11-09 19:14:55 +0100 <johnjay> yes but that's not what i mean
2021-11-09 19:15:23 +0100 <maerwald> and 1 here may be an index, length of a list, and a hundred other things
2021-11-09 19:15:25 +0100ec(~ec@gateway/tor-sasl/ec)
2021-11-09 19:15:30 +0100 <geekosaur> dsal, I feel like they should go back to MS-BASIC
2021-11-09 19:15:35 +0100 <maerwald> that are fine to name explicitly
2021-11-09 19:15:39 +0100ubert(~Thunderbi@2a02:8109:9880:303c:ca5b:76ff:fe29:f233) (Remote host closed the connection)
2021-11-09 19:15:39 +0100 <johnjay> ok how about a simple example. in every file you need an array of length 10
2021-11-09 19:15:49 +0100 <johnjay> so you define it each time instead of one global array
2021-11-09 19:16:15 +0100 <johnjay> whether that was a good idea can only be determined later. that's the problem
2021-11-09 19:17:00 +0100utk1(~utk@43.241.192.170) (WeeChat 2.8)
2021-11-09 19:17:08 +0100 <maerwald> I don't see the problem. You can always refactor later.
2021-11-09 19:17:33 +0100 <dsal> geekosaur: Honestly, I can't tell what are actual arguments and what are strawman. I have code like `thing1 <- errLeft "can't getThing1" =<< getThing1` and they're like, "I can't know what this code does without going to read the definition of `errLeft`" I'm like... are you sure? Maybe it can use a better name, but `getThing1` returns an `Either err Thing1` and you're using a `Thing1` here.
2021-11-09 19:18:43 +0100 <dsal> One of the pieces I suggested changing looks like this: https://usercontent.irccloud-cdn.com/file/QK1uEeLR/abstraction.png
2021-11-09 19:19:13 +0100 <maerwald> the original looks like junior code
2021-11-09 19:19:23 +0100 <dsal> They preferred #1 for readability, but were willing go with #3. I can almost understand that, but I'm having trouble understanding if there's a *real* concern.
2021-11-09 19:19:31 +0100 <dsal> It *was* fairly junior code.
2021-11-09 19:19:45 +0100 <awpr> even the JavaScript community hates the first option enough to add entire language features to avoid it
2021-11-09 19:19:57 +0100utk(~utk@2001:470:69fc:105::1:2fe0)
2021-11-09 19:20:05 +0100 <maerwald> you mean nested promises vs await?
2021-11-09 19:20:06 +0100utk1(~utk@43.241.192.170)
2021-11-09 19:20:07 +0100 <dsal> I was like, "hey, that's harder to follow (it was much longer stuff that marched all the way off the screen)", how about this!? Senior person hated it and thought it made the code harder to read with no value.
2021-11-09 19:20:08 +0100 <awpr> (in the case of promises with cascading nested functions -> async notation for promises)
2021-11-09 19:20:10 +0100 <awpr> yeah
2021-11-09 19:20:28 +0100 <geekosaur> senior person sounds very junior to me
2021-11-09 19:20:31 +0100 <maerwald> I've written nested promises code a long time ago in angular 1 I think
2021-11-09 19:20:44 +0100 <maerwald> sometimes you get your brackets wrong, like in clojure
2021-11-09 19:20:48 +0100 <maerwald> stuff still runs
2021-11-09 19:20:52 +0100 <maerwald> but does something else
2021-11-09 19:21:08 +0100 <dsal> Senior person is very opinionated and has various credentials and stuff. Has some good ideas, but I'm having a difficult time just accepting them without buy-in.
2021-11-09 19:21:21 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net)
2021-11-09 19:21:34 +0100 <johnjay> isn't embedding implicit datastructures in nested case or for loops Always A Bad Idea?
2021-11-09 19:22:01 +0100 <maerwald> dsal: I usually just give up then. The time arguing wastes more of my energy than just abiding by a couple of nonsense.
2021-11-09 19:22:24 +0100jamestmartin(~james@2600:3c01:e000:41d::1) (Quit: ZNC 1.8.2+deb2+b1 - https://znc.in)
2021-11-09 19:22:36 +0100 <johnjay> yes. you don't get to define reality, that's the project manager's job
2021-11-09 19:22:47 +0100 <dsal> Yeah, I just didn't write any code yesterday because it's equivalent to writing code I think is an obvious improvement and then having it rejected for reasons I disagree with and can't be helped to understand.
2021-11-09 19:22:57 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65)
2021-11-09 19:23:18 +0100 <maerwald> e.g. when it's about code formatting, my stance is: "I'll do whatever you want, but please leave me alone with review comments about style, unless those are formalised rules"
2021-11-09 19:23:46 +0100 <maerwald> and I don't want to be involved in any discussions about code formatting
2021-11-09 19:24:01 +0100 <dsal> Right, there are formalized rules. It's a new project and I disagree with some of them, but don't get any say. I really dislike ormolu, but one of the tenants is that someone picks one and everyone has to use it and you can't discuss it.
2021-11-09 19:24:06 +0100 <yin> and if they are formalised rules, just have a stiler do it
2021-11-09 19:24:18 +0100 <maerwald> yin: yeah
2021-11-09 19:24:21 +0100 <geekosaur> tenets?
2021-11-09 19:24:29 +0100 <dsal> Sorry, yeah. heh
2021-11-09 19:24:35 +0100 <maerwald> ormolu is odd, yes
2021-11-09 19:24:43 +0100 <maerwald> forces me to squint
2021-11-09 19:24:49 +0100h187(~coady@185.17.27.105)
2021-11-09 19:24:55 +0100 <dsal> It's not universally terrible, but it does a few things that I think make things more difficult to read.
2021-11-09 19:25:12 +0100mei3(~mei@user/mei) (Read error: Connection reset by peer)
2021-11-09 19:25:21 +0100cheater(~Username@user/cheater) (Ping timeout: 250 seconds)
2021-11-09 19:25:23 +0100 <maerwald> I like this as a style rule: everyone please do whatever the f*** they want.
2021-11-09 19:25:36 +0100 <maerwald> This worked on a pretty large codebase, btw. The world didn't stop.
2021-11-09 19:25:47 +0100yauhsien(~yauhsien@61-231-16-137.dynamic-ip.hinet.net) (Ping timeout: 250 seconds)
2021-11-09 19:25:48 +0100 <geekosaur> I actually think consistent style is a good thing, especially in an indentation sensitive language
2021-11-09 19:25:55 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2021-11-09 19:25:57 +0100 <yin> maerwald: problem is, there are infinite distinct ways of doing the same thing
2021-11-09 19:25:59 +0100 <maerwald> I don't think consistent style serves any purpose
2021-11-09 19:26:08 +0100 <maerwald> except helping some people with their OCD
2021-11-09 19:26:09 +0100 <geekosaur> I don't always agree with the chosen style, but I''ll abide by it
2021-11-09 19:26:46 +0100 <maerwald> yin: it's not a problem... it actually gives me information, because I can see from the style who touched the code (and how many) without even opening git blame
2021-11-09 19:27:02 +0100 <yin> oh i don't mind alignment and such, that's the automatic formatters job
2021-11-09 19:27:02 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65) (Ping timeout: 240 seconds)
2021-11-09 19:27:03 +0100 <exarkun> maerwald: So ... it helps some people? :)
2021-11-09 19:27:23 +0100 <maerwald> I mean, programmers have trained their brains to see patterns...
2021-11-09 19:27:29 +0100 <yin> maerwald: lol
2021-11-09 19:27:33 +0100jakalx(~jakalx@base.jakalx.net)
2021-11-09 19:27:44 +0100utk1(~utk@43.241.192.170) (WeeChat 2.8)
2021-11-09 19:27:47 +0100 <yin> that's one reason i dont like vertical alignment
2021-11-09 19:27:49 +0100 <dsal> ormolu specifically mutilates any alignment or indentation.
2021-11-09 19:27:58 +0100 <maerwald> if you work with your team mates for 6+ months, you'll know every single weird code style they have
2021-11-09 19:28:28 +0100 <dsal> It also really hates putting more than one thing on a line. So you end up with really tall code and reverse indentation.
2021-11-09 19:28:58 +0100mei3(~mei@user/mei)
2021-11-09 19:29:26 +0100 <yin> my brain is trained to read the body of a where clause at char x. vertically aligning stuff by the arbitrary number of characters that it took to define the function makes no sense
2021-11-09 19:29:50 +0100 <dsal> I like having some alignment in my imports and relatively short pattern matching. You know, get the `=` and `->` lined up so you can easily tell the difference between the left side and right side across all cases.
2021-11-09 19:30:04 +0100 <maerwald> oh, but what I believe in is this: use a lot of where clauses with cool names, so that the main function body really reads like prose
2021-11-09 19:30:14 +0100 <yin> dsal: yes, that i consider helpful
2021-11-09 19:30:23 +0100gg(~gg@2a01:e0a:819:1510:4c29:c873:f42e:2b2)
2021-11-09 19:30:28 +0100 <yin> maerwald: yes!
2021-11-09 19:30:44 +0100 <yin> and forget that if then else exists
2021-11-09 19:30:58 +0100 <yin> and use let in sparingly
2021-11-09 19:31:17 +0100 <johnjay> yeah code formatting is definitely one area you need a consistent standard
2021-11-09 19:31:19 +0100 <dsal> elm folks thought that the most important thing in formatters was making sure that whatever diff tool they use shows the smallest diff for any change possible, so they built their canonical formatter around that. ormolu followed. Those with better tools ore other priorities are SOL.
2021-11-09 19:31:25 +0100 <maerwald> it allows you to skip the details and get high-level understanding of what functions do
2021-11-09 19:31:55 +0100 <dsal> yin: It probably wouldn't surprise you that these people prefer `let` over `where` most of the time.
2021-11-09 19:32:17 +0100 <yin> who are these peple?
2021-11-09 19:32:31 +0100 <yin> ^o
2021-11-09 19:32:34 +0100 <johnjay> dsal's coworkers
2021-11-09 19:32:37 +0100 <maerwald> yin: but one problem is that you can't have: 1. where-clauses where functions don't see each other and 2. where-clauses that don't have access to top-level arguments
2021-11-09 19:32:39 +0100jamestmartin(~james@jtmar.me)
2021-11-09 19:32:44 +0100 <johnjay> what I want to know is who "they" are
2021-11-09 19:32:48 +0100 <dsal> yin: one person who's relatively well-known and a bunch of people who are learning Haskell.
2021-11-09 19:33:02 +0100 <maerwald> if there was a GHC extension with more restrictive `where`, I'd use that
2021-11-09 19:33:12 +0100 <dsal> A lot of the arguments are "I, as someone learning Haskell don't understand this thing that you did at first glance."
2021-11-09 19:33:17 +0100 <jkaye> More restrictive how?
2021-11-09 19:33:26 +0100 <maerwald> see above
2021-11-09 19:33:32 +0100 <johnjay> dsal: that's a legitimate argument though. if most of the team is like that
2021-11-09 19:33:54 +0100 <johnjay> my take is you should put a comment saying this is tricky or advanced code
2021-11-09 19:34:09 +0100 <johnjay> instead of punishing someone for using the features the language provides
2021-11-09 19:34:21 +0100 <vaibhavsagar[m]> I will admit to liking `let` over `where`
2021-11-09 19:34:21 +0100 <jkaye> Whoops
2021-11-09 19:34:31 +0100nineonine(~nineonine@2604:3d08:7780:cd00:94f7:1c4f:2fa7:9763)
2021-11-09 19:34:33 +0100 <dsal> johnjay: In abstract, sure. But it degrades to never naming anything because someone won't immediately know what it means and will have to go look it up instead of just writing out lots of stuff all the time.
2021-11-09 19:34:35 +0100 <yin> maerwald: use pattern guards?
2021-11-09 19:34:56 +0100 <yin> (pattern guards are my guilty pleasure)
2021-11-09 19:35:10 +0100 <johnjay> dsal: yeah i don't get that myself. there's nothing wrong with having a URL in the description pointing to some doc in pdf or html to consult
2021-11-09 19:35:14 +0100jamestmartin(~james@jtmar.me) (Remote host closed the connection)
2021-11-09 19:35:17 +0100 <johnjay> sometimes you have to look things up. that's life
2021-11-09 19:35:40 +0100 <maerwald> vaibhavsagar[m]: I think I only use `let` in do notation
2021-11-09 19:35:42 +0100 <geekosaur> shouldn't looking things up be the job of the editor tool (HLS)?
2021-11-09 19:35:53 +0100 <maerwald> no, HLS job is to crash
2021-11-09 19:35:55 +0100 <maerwald> xD
2021-11-09 19:35:57 +0100 <maerwald> jk
2021-11-09 19:36:14 +0100 <dsal> johnjay: Or like, lens is bad because someone saw `_Just` and didn't know what it meant and immediately went to haddock and couldn't understand traversals and blah blah, so I should write a 10 line function every time I need a thing instead of trying to learn something handy in this test. (Not that everyone should use lens all the time, but that's just not a good way to argue)
2021-11-09 19:36:30 +0100 <maerwald> but that has been most of my experience with it
2021-11-09 19:36:38 +0100 <vaibhavsagar[m]> maerwald: my current work codebase has a lot of stuff in `where` clauses and IMO it makes it hard to follow the flow of what's happening
2021-11-09 19:36:57 +0100 <vaibhavsagar[m]> I have to keep jumping back and forth between the definitions and the function body
2021-11-09 19:36:59 +0100 <maerwald> if those are recursive definitions yes
2021-11-09 19:37:28 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f805:19de:1108:4b97) (Remote host closed the connection)
2021-11-09 19:37:37 +0100 <johnjay> vaibhavsagar[m]: having 2 windows open can help a lot with that. i'm just starting to do multi-windows on my incredibly widescreen monitor
2021-11-09 19:37:39 +0100 <dsal> vaibhavsagar[m]: In general, Haskell is declarative. You can write what you want done before you write all of the prerequisites. When it's done well, you only have to jump to those definitions when you need more.
2021-11-09 19:37:44 +0100 <yin> vaibhavsagar[m]: just start by reading the where clauses if the function is not obvious enough (which is a separate problem)
2021-11-09 19:37:47 +0100 <vaibhavsagar[m]> no, these aren't recursive
2021-11-09 19:37:48 +0100 <vaibhavsagar[m]> but even in my own non-work code I like `let` clauses
2021-11-09 19:38:02 +0100h187(~coady@185.17.27.105) (Remote host closed the connection)
2021-11-09 19:38:08 +0100x6C697370(~michael@2600:1700:7c02:3180::49)
2021-11-09 19:38:17 +0100 <dsal> In practice, the difference is between looking up and looking down. Some people strongly want to look up (define all the steps first) and some people want to look down (define the high level goal first, the steps are just details).
2021-11-09 19:38:26 +0100 <vaibhavsagar[m]> it's nice that we have both in Haskell though
2021-11-09 19:39:10 +0100 <vaibhavsagar[m]> I would say I'm the former
2021-11-09 19:39:10 +0100 <yin> ohhh that's where i disagree
2021-11-09 19:39:16 +0100 <vaibhavsagar[m]> but it's also the case that this code doesn't make much sense to me
2021-11-09 19:39:30 +0100 <dsal> There are plenty of reasons the code may not make sense. :)
2021-11-09 19:39:31 +0100 <yin> i prefer having the least ammount of different ways to achieve the same thing, semantically
2021-11-09 19:40:01 +0100 <dsal> Yeah, I agree. let and where are different, but when it doesn't matter, I prefer where. There are different kinds of cases where it matters.
2021-11-09 19:40:19 +0100 <maerwald> could define a new keyword `there`, which disallows recursive definitions and can't access top-level function arguments and
2021-11-09 19:40:45 +0100 <vaibhavsagar[m]> that's nice until the language removes both `let` and `where` since everything is functions anyway
2021-11-09 19:40:47 +0100 <yin> s/semantic/syntactic
2021-11-09 19:41:03 +0100 <yin> maerwald: lol
2021-11-09 19:41:17 +0100 <yin> vaibhavsagar[m]: that sounds great actually
2021-11-09 19:41:22 +0100 <sshine> maerwald, and a 'thine'
2021-11-09 19:41:26 +0100 <vaibhavsagar[m]> https://mail.haskell.org/pipermail/haskell-cafe/2013-July/109116.html
2021-11-09 19:41:46 +0100 <awpr> `heretofore xs = 2 : xs0`
2021-11-09 19:41:53 +0100 <vaibhavsagar[m]> yin: I think it sounds better in theory than practice
2021-11-09 19:42:16 +0100 <sshine> let x = 5. it is known.
2021-11-09 19:42:20 +0100 <awpr> or `henceforth`
2021-11-09 19:42:34 +0100 <vaibhavsagar[m]> it's fine to disagree, but I'm glad we're not working on the same codebase :)
2021-11-09 19:42:36 +0100 <yin> who cares about practice?
2021-11-09 19:42:40 +0100 <awpr> maybe it would implicitly insert its contents as `where` bindings whenever its free variables are in scope
2021-11-09 19:42:47 +0100 <sshine> awpr, henceforth is nice because it wouldn't allow for recursive definitions. :)
2021-11-09 19:43:33 +0100 <dsal> awpr: Ha, dude loves RecordWildCards, but thinks NamedFieldPuns is bad because it just adds extra syntax that's confusing.
2021-11-09 19:44:00 +0100 <yin> i'm tongue in cheek, by the way. this are very minor annoyances, and completely acceptable divergences in _preference_
2021-11-09 19:44:17 +0100 <dsal> He thinks the same about TupleSections which is extra weird to me because I'd think most people would discover that by assuming it works and being told to turn it on. That's how I did, anyway.
2021-11-09 19:44:31 +0100 <yin> awpr: we already have 'otherwise'
2021-11-09 19:44:45 +0100 <dsal> I should start using otherwise randomly.
2021-11-09 19:44:46 +0100utk(~utk@2001:470:69fc:105::1:2fe0) (Quit: Reconnecting)
2021-11-09 19:44:53 +0100 <vaibhavsagar[m]> good to know, I find it hard to read tone sometimes on IRC
2021-11-09 19:44:54 +0100 <maerwald> RecordWildCards are awesome for writing code and terrible for reading it
2021-11-09 19:45:00 +0100utk(~utk@2001:470:69fc:105::1:2fe0)
2021-11-09 19:45:12 +0100 <awpr> `f x = x * x despite y = 5`
2021-11-09 19:45:35 +0100 <dsal> RecordWildCards is sometimes useful. I have a lot of code like let someField = 1; otherField = 2 in T{..}
2021-11-09 19:46:11 +0100 <dsal> I was reading about "Plain English" yesterday. It sounds horrifying.
2021-11-09 19:46:26 +0100 <yin> ?
2021-11-09 19:46:48 +0100 <dsal> Plain English is a programming language where you write all your code in, you know, plain english.
2021-11-09 19:47:12 +0100 <dsal> It sounds insane to me, but this guy seems serious about it: https://osmosianplainenglishprogramming.blog
2021-11-09 19:47:21 +0100 <yin> i hate the philosphy that programming languages should emulate natural ones
2021-11-09 19:47:35 +0100 <dsal> I don't understand it well enough to hate it.
2021-11-09 19:48:09 +0100 <yin> i don't even infix my `on`s
2021-11-09 19:48:29 +0100 <dsal> The idea is that some genius business guy has an idea, but he's frustrated that he has to hire programmers to get programmers to do it. Programmers are annoying and never understand him. If computers just understood plain english, he could be rich without having those annoying intermediates.
2021-11-09 19:48:42 +0100 <dsal> Except like, programmers are compilers. And your specification is terrible.
2021-11-09 19:49:03 +0100 <yin> unless
2021-11-09 19:49:08 +0100 <dsal> unless is banned
2021-11-09 19:49:17 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 264 seconds)
2021-11-09 19:49:20 +0100 <yin> ;)
2021-11-09 19:49:27 +0100 <yin> unless: github copilot
2021-11-09 19:49:48 +0100 <dsal> `when (not $ thing) $ doUnlessThing` is the preferred style.
2021-11-09 19:49:58 +0100 <maerwald> dsal: I actually dislike unless as well
2021-11-09 19:50:02 +0100 <maerwald> there's a great talk about it
2021-11-09 19:50:49 +0100 <dsal> I'd like to hear a great talk about it. :) I mostly just get "X is confusing" for various things that aren't confusing to me and I don't understand how they're confusing to people.
2021-11-09 19:52:13 +0100 <jkaye> I have no issues with unless, or RecordWildCards, or any of these things. Each person is different? Probably the real answer right there
2021-11-09 19:52:57 +0100 <geekosaur> until one such person gets to force their own idiosyncrasies on a bunch of people who don't know any better
2021-11-09 19:53:08 +0100 <monochrom> COBOL used to be the "w00t business types can now code too!" dream.
2021-11-09 19:53:21 +0100 <dsal> RecordWildCards is mostly OK for introducing values into a small scope. I think it's usually terrible to gather bindings and create a value.
2021-11-09 19:53:46 +0100 <maerwald> dsal: https://youtu.be/2mnYf7L7Amw?t=1282
2021-11-09 19:53:48 +0100 <maerwald> there it is
2021-11-09 19:53:50 +0100 <maerwald> hehe
2021-11-09 19:53:59 +0100 <jkaye> geekosaur, Completely different problem there. That person could just as easily force you to use untyped js
2021-11-09 19:54:10 +0100 <dsal> Writing `T { fieldA: something, fieldB: somethingElse }` as `let fieldA = something; fieldB = somethingElse in T{..}` is definitely bad.
2021-11-09 19:54:17 +0100 <awpr> also good for cute tricks like `\T{..} -> T{ x = something, ..}`
2021-11-09 19:54:54 +0100 <dsal> OMG, did you just invent lens?
2021-11-09 19:54:56 +0100 <awpr> admittedly not necessary since you could just record update a variable
2021-11-09 19:55:56 +0100 <awpr> hmm, that may actually be a slightly better way to implement a lens
2021-11-09 19:57:13 +0100 <dsal> I usually just `\t v -> t{x = v}`
2021-11-09 19:58:00 +0100 <monochrom> unless you want to do t{x=x+1}
2021-11-09 19:58:19 +0100 <dsal> I think senior dude who's life work seems to be testing pushed a failing test and went to bed or something.
2021-11-09 19:58:21 +0100 <awpr> if you use `field1 f x = f (field1 x) <&> \f1 -> x { field1 = f1 }`, the whole input record is retained in the closure
2021-11-09 19:58:58 +0100cheater(~Username@user/cheater)
2021-11-09 19:59:14 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65)
2021-11-09 19:59:35 +0100 <awpr> vs. `field1 f T{..} = f field1 <&> \f1 -> T{ field1 = f1, ..}`, that no longer retains the original `field1` value
2021-11-09 19:59:58 +0100 <johnjay> monochrom: so the dream is it requires expertise and study to do X. Wouldn't it be great if we didn't need expertise to do X!?
2021-11-09 20:00:20 +0100 <dsal> I think that's perfectly reasonable.
2021-11-09 20:00:31 +0100 <dsal> The only problem is that people don't realize how bad they are at communicating in English.
2021-11-09 20:00:38 +0100 <johnjay> ^
2021-11-09 20:00:45 +0100 <johnjay> dunning-kruger is rela
2021-11-09 20:00:59 +0100 <awpr> maybe Plain English is a good way to demonstrate to people that their plain English descriptions are nowhere near sufficiently precise
2021-11-09 20:01:16 +0100 <monochrom> I'm cynical, I think the business-type dream is getting rid of all cost centres.
2021-11-09 20:01:18 +0100 <dsal> People feel that they're really good at getting their points across. Someone recently came in here and had a huge wall of stuff nobody could understand and got mad at everyone because he was sure his presentation was perfect.
2021-11-09 20:01:34 +0100 <johnjay> monochrom: i mean isn't that the entire point of automation and AI?
2021-11-09 20:01:39 +0100 <monochrom> Me, I would take it one step further, why not keep humans out of the loop.
2021-11-09 20:01:51 +0100 <dsal> maerwald: Thanks for the link. I think about ruby when I see `unless` so it's kind of funny it came up this way.
2021-11-09 20:01:54 +0100 <johnjay> The arc of history bends toward Butlerian Jihad
2021-11-09 20:02:22 +0100bitdex_(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2021-11-09 20:02:23 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-11-09 20:03:04 +0100 <monochrom> I saw "unless" in Perl, which was long before Ruby existed. I think I also saw it in Racket.
2021-11-09 20:03:41 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65) (Ping timeout: 264 seconds)
2021-11-09 20:03:49 +0100 <dsal> I've managed to forget almost everything I knew about perl.
2021-11-09 20:03:55 +0100 <maerwald> lol
2021-11-09 20:04:09 +0100 <maerwald> I think it's better that way
2021-11-09 20:04:09 +0100 <monochrom> And in Perl you have both "$x=1 unless $y>0" and "$x=1 if $y>0"
2021-11-09 20:04:45 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:dcad:8023:d7ab:9816)
2021-11-09 20:04:55 +0100 <dsal> I think unless at the beginning of a sentence is way less harmful.
2021-11-09 20:04:57 +0100 <monochrom> But you know what, your point still stands. Perl has them precisely because Larry Wall admired plain English, too.
2021-11-09 20:05:32 +0100johnny_sitar(~artur@078088015209.bialystok.vectranet.pl) (Ping timeout: 240 seconds)
2021-11-09 20:06:04 +0100 <monochrom> And this is precisely why I say "so the programming profession attracts the religious delusional type, for example Larry Wall".
2021-11-09 20:06:46 +0100 <monochrom> or rather s/attracts/is left with/
2021-11-09 20:07:30 +0100 <yin> where do the 'lusional' people go?
2021-11-09 20:07:48 +0100 <monochrom> Oh haha so let me repeat my complete analysis again.
2021-11-09 20:09:10 +0100 <monochrom> If you are scientifically minded, e.g., you actually know how to formulate useful hypotheses and properly test them, you would have a more rewarding career as a scientist or a biochem drug researcher. So, the programming profession is deprived of people who actually know how to do testing.
2021-11-09 20:09:51 +0100 <monochrom> If you are good with plain English, you would have a more rewarding career as a writer or even lawyer. So, the programming profession is deprived of people who can actually read/write docs.
2021-11-09 20:10:05 +0100 <davean> monochrom: I think thats true for the masses, but I don't think its generally true
2021-11-09 20:10:42 +0100 <monochrom> If you are good at math, you would have a more rewarding career as a mathematician or even a Wall-Street quant. So, the programming profession is deprived of people who are good at math.
2021-11-09 20:10:51 +0100 <monochrom> So what do we have left?
2021-11-09 20:11:25 +0100 <monochrom> Religious, delusional, bad at math, bad at natural languages. Just look at Larry Wall.
2021-11-09 20:12:24 +0100 <yin> lol
2021-11-09 20:12:43 +0100 <yin> what about logic
2021-11-09 20:12:56 +0100 <davean> yin: humans are horrid at logic, look at the world
2021-11-09 20:13:01 +0100LiaoTao(~LiaoTao@gateway/tor-sasl/liaotao) (Remote host closed the connection)
2021-11-09 20:13:09 +0100 <yin> i want monochrom to answer
2021-11-09 20:13:17 +0100LiaoTao(~LiaoTao@gateway/tor-sasl/liaotao)
2021-11-09 20:13:21 +0100 <maerwald> hmm... and what if you're bad at everything? Become a teacher? ;p
2021-11-09 20:13:24 +0100 <monochrom> I still don't know how to spin that one.
2021-11-09 20:13:26 +0100 <dsal> monochrom: If you're good at Haskell, you would have a more rewarding career as a Cryptocurrency quant.
2021-11-09 20:13:39 +0100 <monochrom> For now I swipe it under the math rug.
2021-11-09 20:13:49 +0100 <monochrom> swipe? shove?
2021-11-09 20:14:08 +0100 <awpr> leave as an exercise for the reader
2021-11-09 20:14:20 +0100 <yin> monochrom: shove? bind?
2021-11-09 20:14:31 +0100 <[exa]> fold
2021-11-09 20:14:45 +0100 <yin> i fold
2021-11-09 20:14:52 +0100 <monochrom> Or, lawyers need logic greatly, too. I can put it there.
2021-11-09 20:15:01 +0100 <davean> maerwald: Now now, teachers are good at ignoring student response
2021-11-09 20:15:22 +0100 <davean> maerwald: I once found a classroom the teacher didn't realize the students spoke spanish, and none had full english proficiency
2021-11-09 20:15:47 +0100 <davean> maerwald: They just declared them behavioral problems instead of noticing they litterly couldn't speak to them
2021-11-09 20:15:48 +0100 <maerwald> xD
2021-11-09 20:16:05 +0100 <monochrom> Knuth says that programming is an extreme special case of teaching.
2021-11-09 20:16:07 +0100 <davean> ... 3 months into the school year and still hadn't figured it out
2021-11-09 20:16:19 +0100 <davean> maerwald: This is seriously not a joke
2021-11-09 20:16:37 +0100 <geekosaur> sweep
2021-11-09 20:16:56 +0100 <monochrom> Oh haha imagine you're coding Haskell for 3 months but you're running the C compiler.
2021-11-09 20:17:20 +0100 <davean> monochrom: only conclusion: Haskell is a horrid language its impossible to write a working program in
2021-11-09 20:18:29 +0100 <davean> maerwald: I have to think tehy were a good complainer too, becaue the other teachers said approximately "they're a wonderful teacher who just is really unlucky and keeps being given the problem kids"
2021-11-09 20:18:45 +0100 <carbolymer> I'm cancelling an async, can I get some kind of stacktrace where exception "has entered" that async?
2021-11-09 20:18:48 +0100dhmohrom^(~dhmohrom@h50.174.139.63.static.ip.windstream.net)
2021-11-09 20:18:52 +0100 <davean> maerwald: So you give teachers too much credit, some of them have things they're good at, and that makes it all the worse
2021-11-09 20:20:31 +0100 <monochrom> Cancellation is internally done by throwing exceptions.
2021-11-09 20:20:31 +0100 <carbolymer> I guess `callStack` will give stack trace at the call place, not where the exception entered the thread
2021-11-09 20:20:39 +0100 <carbolymer> monochrom: yes
2021-11-09 20:20:44 +0100 <geekosaur> davean, that sounds horribly familiar, only I encountered it in first grade
2021-11-09 20:20:47 +0100 <monochrom> Ah then I don't know.
2021-11-09 20:20:55 +0100motherfsck(~motherfsc@user/motherfsck) (Ping timeout: 260 seconds)
2021-11-09 20:21:45 +0100 <maerwald> davean: I only taught a full classroom once... and I could feel the disengagement of every single student... how they didn't understand what I just said, but didn't ask. Leaving you totally helpless. Should you continue or give up?
2021-11-09 20:21:55 +0100 <maerwald> My conclusion: only tutoring works (with maybe 3-5 people)
2021-11-09 20:22:07 +0100 <davean> maerwald: So we have people who specialized in classroom management
2021-11-09 20:22:23 +0100 <davean> and even little things like saying every step seperately an waiting for it to be accomplished went a LONG way
2021-11-09 20:22:26 +0100 <davean> and I mean every step
2021-11-09 20:22:28 +0100johnny_sitar(~artur@078088015209.bialystok.vectranet.pl)
2021-11-09 20:22:29 +0100 <geekosaur> I think maybe 2-3 is considered best
2021-11-09 20:22:31 +0100 <davean> "take out your pencils"
2021-11-09 20:22:32 +0100deadmarshal(~deadmarsh@95.38.112.170) (Ping timeout: 240 seconds)
2021-11-09 20:22:34 +0100 <maerwald> haha
2021-11-09 20:22:35 +0100 <davean> "take out your notebooks"
2021-11-09 20:22:41 +0100 <davean> standing at the front, facing them
2021-11-09 20:22:45 +0100 <sm> Inst: installing globally: `cd; stack install foo`
2021-11-09 20:22:54 +0100 <davean> not doign the standard "take out your pencils and notebook" and then turnign and startign writing on teh board
2021-11-09 20:23:23 +0100 <davean> people speak up and explain themselves more when being waited on explicitely for one
2021-11-09 20:23:30 +0100 <davean> anyway, this is barely Haskell
2021-11-09 20:23:55 +0100mark__(~a@p200300ef973db1e34086f0a6a24fc4dd.dip0.t-ipconnect.de)
2021-11-09 20:24:09 +0100 <davean> but if you want a classroom to respond, IMO, get a psych student who's good and who's only task is to get the classroom stuff done smoothly and they can go home when its done well
2021-11-09 20:24:13 +0100 <davean> don't get a teacher
2021-11-09 20:24:20 +0100 <davean> teacher's don't listen to advice
2021-11-09 20:24:23 +0100unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291)
2021-11-09 20:24:30 +0100 <davean> psych students who want to go home though?
2021-11-09 20:24:33 +0100 <carbolymer> other related question: my thread gets stuck - can I get the stacktrace somehow from that thread? -prof is not an option here
2021-11-09 20:24:34 +0100 <davean> they lit review on their own
2021-11-09 20:25:35 +0100waleee(~waleee@192.165.44.49) (Ping timeout: 246 seconds)
2021-11-09 20:26:51 +0100gg_(~gg@2a01:e0a:819:1510:4c29:c873:f42e:2b2)
2021-11-09 20:28:53 +0100gg(~gg@2a01:e0a:819:1510:4c29:c873:f42e:2b2) (Ping timeout: 264 seconds)
2021-11-09 20:29:43 +0100 <johnjay> monochrom: that is an incredible black pill. but maybe true
2021-11-09 20:30:42 +0100gg_(~gg@2a01:e0a:819:1510:4c29:c873:f42e:2b2) (Read error: Connection reset by peer)
2021-11-09 20:30:56 +0100gg(~gg@2a01:e0a:819:1510:4c29:c873:f42e:2b2)
2021-11-09 20:35:51 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65)
2021-11-09 20:36:32 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-11-09 20:36:32 +0100JimL(~quassel@89-162-2-132.fiber.signal.no) (Ping timeout: 240 seconds)
2021-11-09 20:37:13 +0100dhmohrom^(~dhmohrom@h50.174.139.63.static.ip.windstream.net) (Remote host closed the connection)
2021-11-09 20:38:05 +0100 <dsal> carbolymer: can you get event logs?
2021-11-09 20:38:28 +0100 <dsal> Some builds can dump stacks, but none I've used. :)
2021-11-09 20:39:43 +0100JimL(~quassel@89-162-2-132.fiber.signal.no)
2021-11-09 20:39:55 +0100 <johnjay> monochrom: also i guess if you consider perl to be a bad language that would make more sense
2021-11-09 20:40:17 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65) (Ping timeout: 246 seconds)
2021-11-09 20:40:31 +0100 <monochrom> I don't actually know whether Perl is a bad language. But certainly I don't like many aspects of it.
2021-11-09 20:41:07 +0100 <maerwald> they say perl is for writing, not for reading
2021-11-09 20:41:18 +0100 <dsal> I punished my children whenever brought up perl.
2021-11-09 20:41:21 +0100 <monochrom> That I agree.
2021-11-09 20:41:41 +0100 <monochrom> Along with LaTeX.
2021-11-09 20:42:17 +0100 <mark__> dminuoso: You explained to me that "x = 42; seq x ()" does nothing unless the MMR is :set. I am wondering if this explanation is correct:
2021-11-09 20:42:30 +0100 <mark__> If "42 :: Num a => a" is polymorphic then :sprint can't do anything because a constraint is converted to a simple function parameter in core which means that "42 :: Num a => a" is actually a function in core that is waiting for a dictionary. And a function that is not applied already is in WHNF and therefore "42 :: Num a => a" is in WHNF. It's impossible evaluate any further without the dictionary
2021-11-09 20:42:31 +0100 <mark__> e.g. without knowing the concrete type of "a".
2021-11-09 20:43:06 +0100 <yushyin> it was (is?) an okay glue language back in the days, and the first programming language I learned
2021-11-09 20:43:24 +0100 <johnjay> apparently openssh requires perl to be built
2021-11-09 20:43:33 +0100 <johnjay> lots of random packages you depend on require perl. Xd
2021-11-09 20:43:57 +0100 <maerwald> yeah, often for build system and tests
2021-11-09 20:43:57 +0100 <monochrom> GHC used to require Perl to be built, too. >:) Don't worry, that was a long bygone era.
2021-11-09 20:43:59 +0100 <geekosaur> don't forget that it was only relatively recently that ghc stopped using a perl script when compiling programs (the evil mangler)
2021-11-09 20:51:17 +0100AlexNoo_(~AlexNoo@178.34.163.82)
2021-11-09 20:51:32 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 240 seconds)
2021-11-09 20:51:37 +0100chele_(~chele@user/chele)
2021-11-09 20:51:40 +0100Kaipi(~Kaiepi@156.34.44.192)
2021-11-09 20:52:04 +0100aristid_(sid1599@id-1599.uxbridge.irccloud.com)
2021-11-09 20:52:12 +0100polux7(~polux@51.15.169.172)
2021-11-09 20:52:17 +0100bollu2(~bollu@139.59.46.74)
2021-11-09 20:52:22 +0100drdo6(~drdo@roach0.drdo.eu)
2021-11-09 20:52:26 +0100skn2(~znc@2001:19f0:5:701:5400:ff:fe7c:4e5c)
2021-11-09 20:52:30 +0100Flonk6(~Flonk@ec2-52-40-29-25.us-west-2.compute.amazonaws.com)
2021-11-09 20:52:31 +0100aliosablack(~chomwitt@2a02:587:dc0f:7c00:12c3:7bff:fe6d:d374)
2021-11-09 20:52:32 +0100chomwitt(~chomwitt@2a02:587:dc0f:7c00:12c3:7bff:fe6d:d374) (Ping timeout: 240 seconds)
2021-11-09 20:52:34 +0100skewerr(spoonm@inaba.spoonm.org)
2021-11-09 20:52:42 +0100bbhoss_(sid18216@id-18216.tinside.irccloud.com)
2021-11-09 20:52:43 +0100shanemikel(~shanemike@desk.roadwar.net)
2021-11-09 20:52:44 +0100asthasr_(~asthasr@162.210.28.151)
2021-11-09 20:52:53 +0100pepeiborra_(sid443799@id-443799.ilkley.irccloud.com)
2021-11-09 20:52:58 +0100 <dolio> You guys are too old.
2021-11-09 20:52:59 +0100dispater-(~dispater@user/brprice)
2021-11-09 20:53:05 +0100haskl[error](~haskl@user/haskl)
2021-11-09 20:53:10 +0100loonycyborg_(~loonycybo@chat.chantal.wesnoth.org)
2021-11-09 20:53:11 +0100rtpg_(sid443069@id-443069.ilkley.irccloud.com)
2021-11-09 20:53:15 +0100nitrix_(~nitrix@user/nitrix)
2021-11-09 20:53:17 +0100gonz____(sid304396@id-304396.lymington.irccloud.com)
2021-11-09 20:53:20 +0100lemonsni-(~lemonsnic@cpc159519-perr18-2-0-cust114.19-1.cable.virginm.net)
2021-11-09 20:53:21 +0100dragestil_(~znc@user/dragestil)
2021-11-09 20:53:21 +0100mcfrd(~mcfrdy@user/mcfrdy)
2021-11-09 20:53:52 +0100 <dsal> I had a perl codebase in the millions of lines in the 90s
2021-11-09 20:53:58 +0100np(~nerdypepp@user/nerdypepper)
2021-11-09 20:54:10 +0100cheater1__(~Username@user/cheater)
2021-11-09 20:54:14 +0100 <dolio> It's probably been like 12 years since GHC used the evil mangler.
2021-11-09 20:54:23 +0100Ram-Z_(~Ram-Z@li1814-254.members.linode.com)
2021-11-09 20:54:56 +0100qwedfg_(~qwedfg@user/qwedfg)
2021-11-09 20:55:12 +0100shane_(~shane@ana.rch.ist)
2021-11-09 20:55:15 +0100ski_(~ski@remote12.chalmers.se)
2021-11-09 20:55:17 +0100PigDude_(~PigDude@159.203.16.199)
2021-11-09 20:55:20 +0100Clint_(~Clint@user/clint)
2021-11-09 20:55:24 +0100gentauro_(~gentauro@185.107.12.141)
2021-11-09 20:55:24 +0100tomku|two(~tomku@user/tomku)
2021-11-09 20:55:28 +0100 <monochrom> I am not old enough to have the honour of using 8-inch floppy diskettes or Fortran :)
2021-11-09 20:55:40 +0100ishutin_(~ishutin@92-249-179-61.pool.digikabel.hu)
2021-11-09 20:55:41 +0100reda_(~reda@user/reda)
2021-11-09 20:55:42 +0100mikoto-c1(~mikoto-ch@esm-84-240-99-143.netplaza.fi)
2021-11-09 20:55:45 +0100aweinsto1k(~aweinstoc@cpe-67-248-65-250.nycap.res.rr.com)
2021-11-09 20:55:46 +0100peutri_(~peutri@ns317027.ip-94-23-46.eu)
2021-11-09 20:55:51 +0100hexeme(~hexeme@user/hexeme)
2021-11-09 20:56:02 +0100ezzieygu1wuf(~Unknown@user/ezzieyguywuf)
2021-11-09 20:56:04 +0100ridcully(~ridcully@p57b523cc.dip0.t-ipconnect.de)
2021-11-09 20:56:05 +0100 <monochrom> When I started, it was already 5.25-inch, and BASIC.
2021-11-09 20:56:09 +0100jassob1(~jassob@h-98-128-167-112.NA.cust.bahnhof.se)
2021-11-09 20:56:12 +0100 <dolio> Don't get me wrong, I'm also too old, because it doesn't seem like that long ago to me, either.
2021-11-09 20:56:57 +0100burnsidesLlama(~burnsides@dhcp168-027.wadham.ox.ac.uk)
2021-11-09 20:58:11 +0100 <monochrom> Oh and Lode Runner.
2021-11-09 20:58:29 +0100waleee(~waleee@h-98-128-228-119.NA.cust.bahnhof.se)
2021-11-09 20:58:40 +0100 <monochrom> Anyone wanna reimplement Lode Runner in Haskell so it can't possibly run on an Apple II? >:)
2021-11-09 20:59:14 +0100edro(~edr@enlo.co)
2021-11-09 20:59:15 +0100edro(~edr@enlo.co) (Changing host)
2021-11-09 20:59:15 +0100edro(~edr@user/edr)
2021-11-09 20:59:30 +0100orc(sid509852@user/orc)
2021-11-09 20:59:51 +0100adamCS_(~adamCS@ec2-34-207-160-255.compute-1.amazonaws.com)
2021-11-09 20:59:54 +0100orc(sid509852@user/orc) ()
2021-11-09 21:00:09 +0100xlei_(znc@pool-68-129-84-118.nycmny.fios.verizon.net)
2021-11-09 21:00:45 +0100cheater(~Username@user/cheater) (*.net *.split)
2021-11-09 21:00:46 +0100asthasr(~asthasr@162.210.28.151) (*.net *.split)
2021-11-09 21:00:46 +0100mikoto-chan(~mikoto-ch@esm-84-240-99-143.netplaza.fi) (*.net *.split)
2021-11-09 21:00:46 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (*.net *.split)
2021-11-09 21:00:46 +0100tomku(~tomku@user/tomku) (*.net *.split)
2021-11-09 21:00:46 +0100alx741(~alx741@181.196.68.101) (*.net *.split)
2021-11-09 21:00:46 +0100drdo(~drdo@roach0.drdo.eu) (*.net *.split)
2021-11-09 21:00:46 +0100chele(~chele@user/chele) (*.net *.split)
2021-11-09 21:00:46 +0100jakalx(~jakalx@base.jakalx.net) (*.net *.split)
2021-11-09 21:00:46 +0100haskl(~haskl@user/haskl) (*.net *.split)
2021-11-09 21:00:46 +0100edr(~edr@user/edr) (*.net *.split)
2021-11-09 21:00:46 +0100Flonk(~Flonk@ec2-52-40-29-25.us-west-2.compute.amazonaws.com) (*.net *.split)
2021-11-09 21:00:46 +0100AlexNoo(~AlexNoo@178.34.163.82) (*.net *.split)
2021-11-09 21:00:46 +0100nerdypepper(~nerdypepp@user/nerdypepper) (*.net *.split)
2021-11-09 21:00:46 +0100mcfrdy(~mcfrdy@user/mcfrdy) (*.net *.split)
2021-11-09 21:00:46 +0100ldlework(~hexeme@user/hexeme) (*.net *.split)
2021-11-09 21:00:46 +0100dragestil(~znc@user/dragestil) (*.net *.split)
2021-11-09 21:00:46 +0100skn(~znc@sec.nimmagadda.net) (*.net *.split)
2021-11-09 21:00:46 +0100loonycyborg(~loonycybo@wesnoth/developer/loonycyborg) (*.net *.split)
2021-11-09 21:00:46 +0100spoonm(spoonm@inaba.spoonm.org) (*.net *.split)
2021-11-09 21:00:46 +0100shane(~shane@ana.rch.ist) (*.net *.split)
2021-11-09 21:00:46 +0100PigDude(~PigDude@159.203.16.199) (*.net *.split)
2021-11-09 21:00:46 +0100Clint(~Clint@user/clint) (*.net *.split)
2021-11-09 21:00:46 +0100dispater(~dispater@user/brprice) (*.net *.split)
2021-11-09 21:00:46 +0100Putonlalla(~sapekiis@it-cyan.it.jyu.fi) (*.net *.split)
2021-11-09 21:00:46 +0100reda(~reda@user/reda) (*.net *.split)
2021-11-09 21:00:46 +0100pepeiborra(sid443799@ilkley.irccloud.com) (*.net *.split)
2021-11-09 21:00:46 +0100rtpg(sid443069@ilkley.irccloud.com) (*.net *.split)
2021-11-09 21:00:46 +0100lemonsnicks(~lemonsnic@cpc159519-perr18-2-0-cust114.19-1.cable.virginm.net) (*.net *.split)
2021-11-09 21:00:46 +0100bbhoss(sid18216@tinside.irccloud.com) (*.net *.split)
2021-11-09 21:00:46 +0100aristid(sid1599@uxbridge.irccloud.com) (*.net *.split)
2021-11-09 21:00:46 +0100gonz___(sid304396@lymington.irccloud.com) (*.net *.split)
2021-11-09 21:00:46 +0100jassob(~jassob@h-98-128-167-112.NA.cust.bahnhof.se) (*.net *.split)
2021-11-09 21:00:46 +0100xlei(~akans@pool-68-129-84-118.nycmny.fios.verizon.net) (*.net *.split)
2021-11-09 21:00:46 +0100Ram-Z(~Ram-Z@li1814-254.members.linode.com) (*.net *.split)
2021-11-09 21:00:46 +0100smunix(~smunix@static.26.70.12.49.clients.your-server.de) (*.net *.split)
2021-11-09 21:00:46 +0100Kaiepi(~Kaiepi@156.34.44.192) (*.net *.split)
2021-11-09 21:00:46 +0100qwedfg(~qwedfg@user/qwedfg) (*.net *.split)
2021-11-09 21:00:47 +0100ishutin(~ishutin@92-249-179-61.pool.digikabel.hu) (*.net *.split)
2021-11-09 21:00:47 +0100koolazer(~koo@user/koolazer) (*.net *.split)
2021-11-09 21:00:47 +0100shanemikel_(~shanemike@desk.roadwar.net) (*.net *.split)
2021-11-09 21:00:47 +0100peutri(~peutri@ns317027.ip-94-23-46.eu) (*.net *.split)
2021-11-09 21:00:47 +0100adamCS(~adamCS@ec2-34-207-160-255.compute-1.amazonaws.com) (*.net *.split)
2021-11-09 21:00:47 +0100ridcully_(~ridcully@p57b523cc.dip0.t-ipconnect.de) (*.net *.split)
2021-11-09 21:00:47 +0100bollu(~bollu@139.59.46.74) (*.net *.split)
2021-11-09 21:00:47 +0100canta(~canta@user/canta) (*.net *.split)
2021-11-09 21:00:47 +0100aweinstock(~aweinstoc@cpe-67-248-65-250.nycap.res.rr.com) (*.net *.split)
2021-11-09 21:00:47 +0100moerlitz(d9eb32b7ed@knopi.disroot.org) (*.net *.split)
2021-11-09 21:00:47 +0100gentauro(~gentauro@user/gentauro) (*.net *.split)
2021-11-09 21:00:47 +0100ski(~ski@remote12.chalmers.se) (*.net *.split)
2021-11-09 21:00:47 +0100polux(~polux@51.15.169.172) (*.net *.split)
2021-11-09 21:00:47 +0100nitrix(~nitrix@user/nitrix) (*.net *.split)
2021-11-09 21:00:47 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf) (*.net *.split)
2021-11-09 21:00:47 +0100mcfrdmcfrdy
2021-11-09 21:00:47 +0100xlei_xlei
2021-11-09 21:00:47 +0100nitrix_nitrix
2021-11-09 21:00:47 +0100pepeiborra_pepeiborra
2021-11-09 21:00:47 +0100dragestil_dragestil
2021-11-09 21:00:47 +0100bollu2bollu
2021-11-09 21:00:47 +0100Flonk6Flonk
2021-11-09 21:00:47 +0100bbhoss_bbhoss
2021-11-09 21:00:47 +0100drdo6drdo
2021-11-09 21:00:47 +0100aristid_aristid
2021-11-09 21:00:47 +0100adamCS_adamCS
2021-11-09 21:00:47 +0100polux7polux
2021-11-09 21:00:47 +0100rtpg_rtpg
2021-11-09 21:00:55 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-11-09 21:00:55 +0100cheater1__cheater
2021-11-09 21:01:03 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2021-11-09 21:01:28 +0100zebrag(~chris@user/zebrag)
2021-11-09 21:01:31 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2021-11-09 21:01:59 +0100 <geekosaur> [09 19:55:28] <monochrom> I am not old enough to have the honour of using 8-inch floppy diskettes or Fortran :)
2021-11-09 21:02:02 +0100aweinsto1kaweinstock
2021-11-09 21:02:03 +0100 <geekosaur> lucky you
2021-11-09 21:04:11 +0100Clint_Clint
2021-11-09 21:05:00 +0100juhp(~juhp@128.106.188.220) (Ping timeout: 244 seconds)
2021-11-09 21:06:52 +0100Topsi(~Tobias@dyndsl-095-033-024-160.ewe-ip-backbone.de)
2021-11-09 21:07:11 +0100koolazer(~koo@user/koolazer)
2021-11-09 21:07:23 +0100juhp(~juhp@128.106.188.220)
2021-11-09 21:07:49 +0100canta(~canta@user/canta)
2021-11-09 21:08:46 +0100alx741(~alx741@181.196.68.101)
2021-11-09 21:09:16 +0100Putonlalla(~sapekiis@it-cyan.it.jyu.fi)
2021-11-09 21:12:21 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:dcad:8023:d7ab:9816) (Remote host closed the connection)
2021-11-09 21:12:25 +0100 <unit73e> lol I only used a 8-inch floppy disk once
2021-11-09 21:13:28 +0100 <unit73e> 3 1/2 was already the norm, and it was the high density version
2021-11-09 21:13:55 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:dcad:8023:d7ab:9816)
2021-11-09 21:18:58 +0100 <unit73e> even 5 1/2 was dead already
2021-11-09 21:19:53 +0100 <geekosaur> now I'm remembering SLS on 50 5¼ floppies
2021-11-09 21:20:50 +0100 <sm> I want Lode Runner in haskell!
2021-11-09 21:21:47 +0100 <carbolymer> dsal: what do you mean by event logs? those from SIGUSR2?
2021-11-09 21:22:15 +0100 <dsal> carbolymer: sigquit, I think
2021-11-09 21:22:19 +0100 <dsal> It'll tell you. :)
2021-11-09 21:22:24 +0100 <geekosaur> -eventlog runtime parameter? which requires recompiling with eventlog support, so if profiling is out so may be that
2021-11-09 21:22:41 +0100 <unit73e> sm, lol I am making SDL2 real world examples lol. Had some trouble loading a sprite sheet with spritesheepacker and loading the result with aeson but managed to do it. Lode Runner shouldn't be hard.
2021-11-09 21:23:42 +0100 <dsal> carbolymer: I've traced that kind of issue with eventlog, which also had me have to name all of my threads so I knew what I was looking at. Then I wrote a custom eventlog regret l reader that would tell me my problem.
2021-11-09 21:24:05 +0100 <unit73e> lazyfoo examples are not what a game dev would do. he did it while learning in college.
2021-11-09 21:24:10 +0100 <dsal> It was rare... Like once a month on a relatively busy server. Bad connection where just wrong.
2021-11-09 21:25:38 +0100 <carbolymer> dsal: same, in our case thread gets stuck also once in a month
2021-11-09 21:26:25 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65)
2021-11-09 21:26:26 +0100 <dsal> Neat. The stuff I did with eventlog was really helpful. I did have to name everything, though.
2021-11-09 21:26:46 +0100emf(~emf@2620:10d:c090:400::5:b872) (Ping timeout: 245 seconds)
2021-11-09 21:27:44 +0100 <dsal> I.e., I made a `namedAsync` and used it for all my calls so the threads had names telling me what was going on.
2021-11-09 21:27:48 +0100thedward[m](~thedwardm@2001:470:69fc:105::f79)
2021-11-09 21:28:02 +0100 <carbolymer> nice
2021-11-09 21:28:10 +0100 <carbolymer> I'll look into that, thanks dsal
2021-11-09 21:28:24 +0100emf(~emf@2620:10d:c090:400::5:defd)
2021-11-09 21:29:06 +0100gehmehgeh(~user@user/gehmehgeh) (Remote host closed the connection)
2021-11-09 21:29:43 +0100 <geekosaur> I think my first "job" was doing backups on a machine with an 8" drive. boring as all get-out.
2021-11-09 21:29:57 +0100random-jellyfish(~random-je@user/random-jellyfish)
2021-11-09 21:30:09 +0100gehmehgeh(~user@user/gehmehgeh)
2021-11-09 21:30:32 +0100zincy(~zincy@2a00:23c8:970c:4801:350f:7ee:191a:6f65) (Ping timeout: 240 seconds)
2021-11-09 21:31:11 +0100 <dsal> carbolymer: this is there commit where I did a bunch of that: https://github.com/dustin/mqtt-hs/commit/7668dcd8c2173f7703769e1b0044f80e0ae063a7
2021-11-09 21:31:49 +0100 <carbolymer> dsal: that's suprisingly clean
2021-11-09 21:32:02 +0100 <sm> oh now.. I bet an accurate Lode Runner is quite hard
2021-11-09 21:32:08 +0100 <dsal> Looks like this was my bug fix: https://github.com/dustin/mqtt-hs/commit/50634bada037406bceba7ab13fd7632a97a2ff82
2021-11-09 21:32:25 +0100 <dsal> Stuff was getting parked in stm when a disconnection happened at exactly the right time.
2021-11-09 21:33:38 +0100 <dsal> The eventlog reader was a one off, but I think I still have it.
2021-11-09 21:34:14 +0100neurocyte0132889(~neurocyte@user/neurocyte) (Quit: The Lounge - https://thelounge.chat)
2021-11-09 21:34:17 +0100Lycurgus(~juan@98.4.112.204)
2021-11-09 21:36:32 +0100mei3(~mei@user/mei) (Ping timeout: 240 seconds)
2021-11-09 21:37:04 +0100 <carbolymer> I wonder if in those GHC events I would be able to find out where my thread gets stuck, it seems that's mostly log of events (like the name suggests), not sure if there's an event for "HALP I'M STUCK HERE FOR 4 HRS" from a thread
2021-11-09 21:37:38 +0100random-jellyfish(~random-je@user/random-jellyfish) (Quit: Client closed)
2021-11-09 21:38:29 +0100hexemeldlework
2021-11-09 21:38:41 +0100acidjnk_new3(~acidjnk@p200300d0c7149f82889e7e27a4cfa8d6.dip0.t-ipconnect.de)
2021-11-09 21:39:27 +0100emf(~emf@2620:10d:c090:400::5:defd) (Read error: Connection reset by peer)
2021-11-09 21:39:29 +0100emf_(~emf@2620:10d:c090:400::5:defd)
2021-11-09 21:39:51 +0100neurocyte0132889(~neurocyte@212.232.89.58)
2021-11-09 21:39:51 +0100neurocyte0132889(~neurocyte@212.232.89.58) (Changing host)
2021-11-09 21:39:51 +0100neurocyte0132889(~neurocyte@user/neurocyte)
2021-11-09 21:41:24 +0100 <dsal> I can't remember what my thing did but it answered my question quickly.
2021-11-09 21:42:19 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-11-09 21:42:20 +0100 <dsal> You can add stuff like timeouts and extra info.
2021-11-09 21:42:45 +0100 <dsal> In my case, I think it was "where did the currently running threads start?"
2021-11-09 21:43:28 +0100 <dsal> Then I used my brain runtime to debug.
2021-11-09 21:44:29 +0100emf_(~emf@2620:10d:c090:400::5:defd) (Read error: Connection reset by peer)
2021-11-09 21:44:42 +0100emf(~emf@2620:10d:c090:400::5:defd)
2021-11-09 21:47:11 +0100vysn(~vysn@user/vysn) (Ping timeout: 245 seconds)
2021-11-09 21:47:21 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-11-09 21:48:35 +0100acidjnk_new(~acidjnk@p200300d0c724a7710420fe3aa4fdb454.dip0.t-ipconnect.de)
2021-11-09 21:49:33 +0100emf(~emf@2620:10d:c090:400::5:defd) (Read error: Connection reset by peer)
2021-11-09 21:49:52 +0100emf(~emf@2620:10d:c090:400::5:defd)
2021-11-09 21:51:32 +0100acidjnk_new3(~acidjnk@p200300d0c7149f82889e7e27a4cfa8d6.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2021-11-09 21:53:30 +0100AlexNoo_AlexNoo
2021-11-09 21:58:42 +0100_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-11-09 22:00:12 +0100SeungheonOh(~Thunderbi@2600:1700:5168:1400:7f33:b84f:d388:a0fc)
2021-11-09 22:00:55 +0100gg(~gg@2a01:e0a:819:1510:4c29:c873:f42e:2b2) (Read error: Connection reset by peer)
2021-11-09 22:01:02 +0100emf_(~emf@163.114.130.1)
2021-11-09 22:01:03 +0100gg(~gg@2a01:e0a:819:1510:4c29:c873:f42e:2b2)
2021-11-09 22:02:11 +0100emf(~emf@2620:10d:c090:400::5:defd) (Ping timeout: 245 seconds)
2021-11-09 22:02:17 +0100 <dsal> carbolymer: This was the hack I used to figure out what threads were running: https://gist.github.com/dustin/2ca9e66543c4e5c5158650f790454a99
2021-11-09 22:02:58 +0100 <carbolymer> nice, thanks
2021-11-09 22:04:44 +0100dsalIt's gross and I don't even know what it was supposed to do, but it did it. :)
2021-11-09 22:06:06 +0100x_kuru(~xkuru@user/xkuru)
2021-11-09 22:06:49 +0100Lycurgus(~juan@98.4.112.204) (Quit: Exeunt)
2021-11-09 22:07:45 +0100emf_(~emf@163.114.130.1) (Ping timeout: 256 seconds)
2021-11-09 22:07:47 +0100emf(~emf@2620:10d:c090:400::5:defd)
2021-11-09 22:08:17 +0100xkuru(~xkuru@user/xkuru) (Ping timeout: 250 seconds)
2021-11-09 22:09:00 +0100kuribas(~user@ptr-25vy0i9fqz6dux8z18z.18120a2.ip6.access.telenet.be) (Remote host closed the connection)
2021-11-09 22:14:56 +0100emf(~emf@2620:10d:c090:400::5:defd) (Read error: Connection reset by peer)
2021-11-09 22:14:57 +0100emf_(~emf@2620:10d:c090:400::5:defd)
2021-11-09 22:16:31 +0100aliosablack(~chomwitt@2a02:587:dc0f:7c00:12c3:7bff:fe6d:d374) (Ping timeout: 250 seconds)
2021-11-09 22:16:47 +0100shaprattaches a debugger to his brain
2021-11-09 22:18:51 +0100gg(~gg@2a01:e0a:819:1510:4c29:c873:f42e:2b2) (Ping timeout: 245 seconds)
2021-11-09 22:20:01 +0100emf_(~emf@2620:10d:c090:400::5:defd) (Read error: Connection reset by peer)
2021-11-09 22:20:05 +0100emf(~emf@163.114.132.5)
2021-11-09 22:20:55 +0100 <dsal> There's some ugly stuff in there. Like, what's `\Event{evTime} -> evTime`
2021-11-09 22:21:54 +0100Pickchea(~private@user/pickchea)
2021-11-09 22:22:36 +0100lavaman(~lavaman@98.38.249.169)
2021-11-09 22:25:25 +0100emf_(~emf@2620:10d:c090:400::5:4199)
2021-11-09 22:26:46 +0100emf(~emf@163.114.132.5) (Ping timeout: 260 seconds)
2021-11-09 22:27:14 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 260 seconds)
2021-11-09 22:27:38 +0100dolio(~dolio@130.44.130.54) (Ping timeout: 268 seconds)
2021-11-09 22:27:49 +0100dolio(~dolio@130.44.130.54)
2021-11-09 22:29:05 +0100cjb(~cjbayliss@user/cjb)
2021-11-09 22:32:12 +0100 <[exa]> dsal: field pattern?
2021-11-09 22:32:39 +0100 <[exa]> ah that was not a question. :D
2021-11-09 22:34:22 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:dcad:8023:d7ab:9816) (Remote host closed the connection)
2021-11-09 22:39:40 +0100Topsi(~Tobias@dyndsl-095-033-024-160.ewe-ip-backbone.de) (Read error: Connection reset by peer)
2021-11-09 22:43:19 +0100SeungheonOh(~Thunderbi@2600:1700:5168:1400:7f33:b84f:d388:a0fc) (Quit: SeungheonOh)
2021-11-09 22:45:17 +0100 <carbolymer> ;)
2021-11-09 22:45:25 +0100 <carbolymer> dsal: but it works!
2021-11-09 22:45:58 +0100cjb(~cjbayliss@user/cjb) ()
2021-11-09 22:46:01 +0100 <carbolymer> when I was doing java, I missed Haskell's abstractions
2021-11-09 22:46:09 +0100 <carbolymer> now I'm doing Haskell, I miss JVM instrumentation
2021-11-09 22:46:16 +0100pavonia(~user@user/siracusa)
2021-11-09 22:47:13 +0100 <sm> ekg, any good ?
2021-11-09 22:47:43 +0100cjb(~cjbayliss@user/cjb)
2021-11-09 22:48:03 +0100 <carbolymer> yeah, ekg is okayish
2021-11-09 22:49:13 +0100biberu(~biberu@user/biberu) (Read error: Connection reset by peer)
2021-11-09 22:50:27 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2021-11-09 22:55:47 +0100 <maerwald> iohk-monitoring-framework uses it
2021-11-09 22:56:16 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:dcad:8023:d7ab:9816)
2021-11-09 22:57:24 +0100 <maerwald> https://github.com/input-output-hk/iohk-monitoring-framework/blob/master/plugins/backend-ekg/src/C…
2021-11-09 22:59:34 +0100 <carbolymer> that looks impressive
2021-11-09 22:59:49 +0100 <carbolymer> are they writing all their code as literate haskell?\
2021-11-09 23:00:36 +0100 <maerwald> it's probably one of their worst libraries
2021-11-09 23:00:38 +0100 <maerwald> :D
2021-11-09 23:00:46 +0100 <carbolymer> haha
2021-11-09 23:00:47 +0100 <carbolymer> why
2021-11-09 23:00:56 +0100 <maerwald> well, try to use it and check the documentation
2021-11-09 23:00:58 +0100 <carbolymer> I haven't figured out what it really does
2021-11-09 23:00:59 +0100 <carbolymer> though
2021-11-09 23:03:34 +0100notzmv(~zmv@user/notzmv)
2021-11-09 23:03:51 +0100biberu(~biberu@user/biberu)
2021-11-09 23:05:06 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2021-11-09 23:07:52 +0100 <dsal> carbolymer: When I started doing java, I missed squeak's instrumentation. heh
2021-11-09 23:07:54 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:dcad:8023:d7ab:9816) (Remote host closed the connection)
2021-11-09 23:07:59 +0100zebrag(~chris@user/zebrag) (Remote host closed the connection)
2021-11-09 23:08:31 +0100 <dsal> This is some stuff I was doing in haskell a couple weeks ago: https://usercontent.irccloud-cdn.com/file/8saPPh6O/ping.png
2021-11-09 23:09:12 +0100biberu(~biberu@user/biberu) (Read error: Connection reset by peer)
2021-11-09 23:09:28 +0100 <carbolymer> dsal: that's nice, realy informative
2021-11-09 23:09:30 +0100 <dsal> I wrote some literate haskell in markdown at my last job. It was pretty neat since our source browser rendered markdown and also the flow diagrams I was using inside of the file and stuff.
2021-11-09 23:10:20 +0100 <dsal> carbolymer: It's more than it appears at first! The little /\ is pointing to when a postgres lock was acquired. Understanding what the actual code is doing, you can tell exactly when a connection was acquired from a pool, what had it last, when it asked for a lock, when it got a lock, and how long each little piece of the transaction took.
2021-11-09 23:10:59 +0100 <dsal> Also, this kind of thing: https://usercontent.irccloud-cdn.com/file/qpJ9Y6E1/query.png
2021-11-09 23:11:19 +0100 <carbolymer> wow
2021-11-09 23:11:55 +0100 <carbolymer> thats from output from event log, or -prof?
2021-11-09 23:11:59 +0100 <dsal> eventlog
2021-11-09 23:12:11 +0100 <carbolymer> that's a lot of data
2021-11-09 23:12:11 +0100 <carbolymer> nice
2021-11-09 23:12:13 +0100zebrag(~chris@user/zebrag)
2021-11-09 23:12:55 +0100Inst(~Inst@2601:6c4:4080:3f80:c951:41b3:1b4a:c1f9)
2021-11-09 23:13:21 +0100 <dsal> This is opentelemetry. It also covers distributed traces, though the viewing tool I was using can't actually show that. You could trace a new connection being made to the DB back to the function that issued the request in another process.
2021-11-09 23:13:51 +0100biberu(~biberu@user/biberu)
2021-11-09 23:14:20 +0100 <dsal> Yeah, I didn't even get a screenshot of that because this tool couldn't do it.
2021-11-09 23:14:45 +0100kupi(uid212005@id-212005.hampstead.irccloud.com)
2021-11-09 23:19:56 +0100 <mark__> Still confused regarding WHNF. 1) Is a partially applied value constructor in WHNF, like (:) True ? 2) Is a lambda abstraction applied to an argument in WHNF, like (\x -> x) "A" ?
2021-11-09 23:22:40 +0100zincy(~zincy@host86-181-60-139.range86-181.btcentralplus.com)
2021-11-09 23:24:46 +0100 <mark__> I think the expression in "x = \(x :: Int) -> x" is in WHNF. There is nothing that could be evaluated but "seq x (); :sprint x" returns "x = _". Is this because a lambda is not showable?
2021-11-09 23:27:05 +0100zincy(~zincy@host86-181-60-139.range86-181.btcentralplus.com) (Ping timeout: 256 seconds)
2021-11-09 23:27:16 +0100gg(~gg@2a01:e0a:819:1510:e434:efd5:edf7:7caa)
2021-11-09 23:28:32 +0100johnny_sitar(~artur@078088015209.bialystok.vectranet.pl) (Ping timeout: 240 seconds)
2021-11-09 23:35:21 +0100 <lyxia> Yeah
2021-11-09 23:35:27 +0100 <geekosaur> right, lambdas are in WHNF but there's nothing to show
2021-11-09 23:35:33 +0100 <geekosaur> they have to be applied
2021-11-09 23:39:44 +0100sprout_(~quassel@2a02:a467:ccd6:1:e1e5:75f2:6059:4431)
2021-11-09 23:42:52 +0100sprout(~quassel@2a02:a467:ccd6:1:e9:abf1:b887:13fa) (Ping timeout: 268 seconds)
2021-11-09 23:43:24 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-11-09 23:45:54 +0100unit73e(~emanuel@2001:818:e8dd:7c00:32b5:c2ff:fe6b:5291) (Quit: Leaving)
2021-11-09 23:46:41 +0100falafel(~falafel@cpe-76-168-195-162.socal.res.rr.com)
2021-11-09 23:47:58 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-11-09 23:48:17 +0100mcgroin(~mcgroin@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2021-11-09 23:49:44 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:dcad:8023:d7ab:9816)
2021-11-09 23:51:26 +0100gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-11-09 23:58:04 +0100 <monochrom> Partially applied value constructor is translated to lambda, e.g., "(:) True" means \y -> True : y
2021-11-09 23:58:37 +0100 <byorgey> mark__: (1) yes, (2) no
2021-11-09 23:58:55 +0100 <monochrom> In fact let's not fear 0. (:) = \x y -> x : y