IRCBrowse

2021/02/22

2021-02-22 00:04:27 +0100totte(~totte@chakra/totte) (Ping timeout: 265 seconds)
2021-02-22 00:05:40 +0100conal(~conal@64.71.133.70)
2021-02-22 00:06:33 +0100Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi) (Quit: Leaving.)
2021-02-22 00:06:35 +0100o1lo01ol1o(~o1lo01ol1@bl11-140-216.dsl.telepac.pt) (Remote host closed the connection)
2021-02-22 00:06:43 +0100ddellacosta(~ddellacos@86.106.143.46) (Remote host closed the connection)
2021-02-22 00:06:47 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 00:07:21 +0100totte(~totte@chakra/totte)
2021-02-22 00:11:19 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-22 00:12:57 +0100jedws(~jedws@101.184.202.248)
2021-02-22 00:13:23 +0100conal(~conal@64.71.133.70)
2021-02-22 00:14:22 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:e027:ed4b:9a92:9af6) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 00:15:07 +0100__monty__(~toonn@unaffiliated/toonn) (Quit: leaving)
2021-02-22 00:16:28 +0100gzj(~gzj@unaffiliated/gzj)
2021-02-22 00:19:30 +0100lemmih(~lemmih@2406:3003:2072:44:15d3:24ba:467f:3d99)
2021-02-22 00:21:10 +0100son0p(~son0p@181.136.122.143) (Ping timeout: 260 seconds)
2021-02-22 00:21:19 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 00:22:55 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:e027:ed4b:9a92:9af6)
2021-02-22 00:23:30 +0100jchia(~jchia@218.80.77.165)
2021-02-22 00:24:18 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-22 00:24:31 +0100 <swarmcollective> "Well honk my hooter..." maybe there is a Haskell library for everything already? http://hackage.haskell.org/package/cqrs-core :D
2021-02-22 00:25:22 +0100alx741(~alx741@186.178.109.47) (Ping timeout: 260 seconds)
2021-02-22 00:26:46 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-02-22 00:27:33 +0100Benzi-Junior(~BenziJuni@88-149-67-143.du.xdsl.is) (Ping timeout: 264 seconds)
2021-02-22 00:28:01 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-jfcqcaqnxdwadhys) (Quit: Connection closed for inactivity)
2021-02-22 00:28:19 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh) (Quit: Leaving)
2021-02-22 00:29:50 +0100conal(~conal@64.71.133.70)
2021-02-22 00:30:38 +0100xff0x(~xff0x@2001:1a81:52c4:2f00:8c9d:1c49:2ec6:afff) (Ping timeout: 264 seconds)
2021-02-22 00:31:04 +0100xff0x(~xff0x@2001:1a81:52c4:2f00:ca8f:9e28:67a8:bae5)
2021-02-22 00:31:11 +0100nullniverse(~null@unaffiliated/nullniverse)
2021-02-22 00:31:36 +0100nullniv93(~null@unaffiliated/nullniverse) (Ping timeout: 240 seconds)
2021-02-22 00:32:22 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2021-02-22 00:37:30 +0100acidjnk_new(~acidjnk@pd9e0bf4a.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2021-02-22 00:37:40 +0100kam1(~kam1@37.129.135.98) (Ping timeout: 256 seconds)
2021-02-22 00:37:55 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:e027:ed4b:9a92:9af6) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 00:38:09 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-02-22 00:38:31 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr)
2021-02-22 00:39:49 +0100alx741(~alx741@186.178.109.47)
2021-02-22 00:41:38 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-22 00:42:07 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net)
2021-02-22 00:43:15 +0100 <jackdk> Does anyone know the name of the three-element semiring with elements "zero, one, many"?
2021-02-22 00:44:12 +0100 <MarcelineVQ> rig?
2021-02-22 00:45:06 +0100nullniv46(~null@unaffiliated/nullniverse)
2021-02-22 00:45:08 +0100 <MarcelineVQ> oh that's the general name zero,one,many fits under, hmm..
2021-02-22 00:45:44 +0100 <dolio> Rig is just a mnemonic for what semiring means, yeah.
2021-02-22 00:45:52 +0100xff0x(~xff0x@2001:1a81:52c4:2f00:ca8f:9e28:67a8:bae5) (Ping timeout: 260 seconds)
2021-02-22 00:46:07 +0100nullniverse(~null@unaffiliated/nullniverse) (Read error: Connection reset by peer)
2021-02-22 00:46:09 +0100 <Axman6> swarmcollective: you might also want to look at acid-state too. it's a bit old now, and I think if it were rewritten it would benefit from doing a bit mor ein the type system
2021-02-22 00:46:17 +0100xff0x(~xff0x@2001:1a81:52c4:2f00:fa7c:56b7:c532:c584)
2021-02-22 00:46:45 +0100 <swarmcollective> Axman6, thank you, I'll check it out!
2021-02-22 00:46:50 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net) (Ping timeout: 260 seconds)
2021-02-22 00:48:56 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 00:50:05 +0100 <MarcelineVQ> jackdk: I just see it called "zero-one-many semiring" https://bentnib.org/quantitative-type-theory.pdf
2021-02-22 00:50:57 +0100alx741(~alx741@186.178.109.47) (Quit: alx741)
2021-02-22 00:54:03 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 256 seconds)
2021-02-22 00:56:41 +0100Lowl3v3l(~Lowl3v3l@dslb-002-203-233-121.002.203.pools.vodafone-ip.de) (Remote host closed the connection)
2021-02-22 00:57:05 +0100Aquazi(uid312403@gateway/web/irccloud.com/x-pjlkokppvykdzkgr) (Quit: Connection closed for inactivity)
2021-02-22 00:58:44 +0100 <monochrom> The GUI semiring: don't click, click, double click, rage click.
2021-02-22 00:58:49 +0100 <MarcelineVQ> jackdk: closest thing to a name I see is a the general name, R, for (R)esource semiring
2021-02-22 01:00:06 +0100atk(~Arch-TK@ircpuzzles/staff/Arch-TK) (Quit: Well this is unexpected.)
2021-02-22 01:01:27 +0100atk(~Arch-TK@ircpuzzles/staff/Arch-TK)
2021-02-22 01:02:27 +0100ski. o O ( degree and codegree rigs -- "Objects of Categories as Complex Numbers" by Marcelo Fiore,Tom Leinster in 2002-12-30 at <https://arxiv.org/abs/math/0212377> -- cf. <https://golem.ph.utexas.edu/category/2009/07/searching_for_a_video_proof_of.html> )
2021-02-22 01:03:10 +0100stree(~stree@68.36.8.116) (Ping timeout: 260 seconds)
2021-02-22 01:03:11 +0100m0rphism1(~m0rphism@HSI-KBW-085-216-104-059.hsi.kabelbw.de) (Ping timeout: 272 seconds)
2021-02-22 01:05:05 +0100ambiso9(~ambiso@209.182.239.205) (Quit: Ping timeout (120 seconds))
2021-02-22 01:06:04 +0100ambiso9(~ambiso@209.182.239.205)
2021-02-22 01:10:16 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:b8ec:ecd4:c92c:f02:3202)
2021-02-22 01:11:57 +0100nullniv46(~null@unaffiliated/nullniverse) (Read error: Connection reset by peer)
2021-02-22 01:11:58 +0100conal(~conal@64.71.133.70)
2021-02-22 01:12:02 +0100nullniverse(~null@unaffiliated/nullniverse)
2021-02-22 01:13:30 +0100 <Axman6> "Monads themselves are a very interesting concept and are very heavily used by the functional programming community to handle "impurity"." -_- The my perpetuates: https://www.eltonpinto.me/blog/posts/implementing_flatmap_in_rust/
2021-02-22 01:13:35 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:e027:ed4b:9a92:9af6)
2021-02-22 01:14:21 +0100carlomagno(~cararell@148.87.23.5) (Ping timeout: 264 seconds)
2021-02-22 01:14:47 +0100 <pjb> Axman6: I wanted to do pure functional programming, and all I hear is monads and impurity..
2021-02-22 01:15:02 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net)
2021-02-22 01:15:41 +0100 <h2017> monads are pure
2021-02-22 01:15:44 +0100 <c_wraith> monads aren't impurity
2021-02-22 01:15:49 +0100 <c_wraith> monads might *model* impurity
2021-02-22 01:15:52 +0100stree(~stree@68.36.8.116)
2021-02-22 01:15:54 +0100 <c_wraith> but that's a very different thing
2021-02-22 01:15:54 +0100 <Axman6> ym=myth*
2021-02-22 01:16:36 +0100 <minoru_shiraeesh> h2017: "monads are pure" - except IO?
2021-02-22 01:16:41 +0100 <Axman6> IO is pure
2021-02-22 01:16:42 +0100 <c_wraith> nope
2021-02-22 01:16:49 +0100 <h2017> you can have non-pure instances
2021-02-22 01:16:51 +0100ghais(4c616ae2@gateway/web/cgi-irc/kiwiirc.com/ip.76.97.106.226)
2021-02-22 01:16:53 +0100 <c_wraith> here's the thing: "purity" applies to functions
2021-02-22 01:17:05 +0100 <h2017> the idea doesn't depend on anything being impure i guess
2021-02-22 01:17:36 +0100 <c_wraith> unsafePerformIO is impure
2021-02-22 01:17:47 +0100 <Axman6> purity means, that f (g x) (g x) is the same as let gx = g x in f gx gx, and this is still true of IO
2021-02-22 01:17:55 +0100alx741(~alx741@186.178.109.47)
2021-02-22 01:18:06 +0100 <minoru_shiraeesh> c_wraith: "unsafePerformIO is impure" - and main maybe
2021-02-22 01:18:17 +0100 <c_wraith> Nope. main is inert.
2021-02-22 01:18:20 +0100 <c_wraith> it's just a value.
2021-02-22 01:18:32 +0100 <c_wraith> It's not even a function
2021-02-22 01:18:39 +0100 <c_wraith> "purity" as an idea only applies to functions
2021-02-22 01:18:39 +0100 <minoru_shiraeesh> the thing that runs the action that main returned then
2021-02-22 01:18:44 +0100 <Axman6> you can pass main around any way you want, it's not special, other than being where execution begins
2021-02-22 01:21:18 +0100 <c_wraith> the thing that executes main *is* decidedly impure. But it's out of the scope of a Haskell program
2021-02-22 01:22:15 +0100 <Axman6> it's completely possible to have a pure RTS, it just wou;ldn't be very useful. Think of main as the recipe for telling the RTS what interactions you want it to perform for you with the outside world.
2021-02-22 01:23:26 +0100Deide(~Deide@217.155.19.23) (Quit: Seeee yaaaa)
2021-02-22 01:25:18 +0100 <minoru_shiraeesh> what do you think about this analogy? you either do something, or you just think and do nothing. but you can talk. talking is halfway between thinking and acting.
2021-02-22 01:25:57 +0100 <minoru_shiraeesh> if thinking is pure, and acting is like a thing that executes an action, then main is like talking
2021-02-22 01:26:26 +0100 <minoru_shiraeesh> when you talk, you don't do anything, but you do something
2021-02-22 01:26:36 +0100 <minoru_shiraeesh> it is physical action too
2021-02-22 01:26:58 +0100 <ghais> Hi all, i am trying to understand a problem i have with type constraints. I created a small example the demonstrates the problem here https://gist.github.com/ghais/2911a582d712a4cafe244b826654cdab the compiler errors out about a missing constraint (Coordinate c0), but i feel the constraints here are sufficient for this function. I tried adding a
2021-02-22 01:26:59 +0100 <ghais> forall quantifier which reduced the errors but ultimately produced a similar error
2021-02-22 01:27:09 +0100 <ghais> would anyone be able to help me understand this use case?
2021-02-22 01:27:35 +0100Sonderblade(~helloman@94.191.136.141.mobile.tre.se) (Ping timeout: 265 seconds)
2021-02-22 01:27:53 +0100oisdk(~oisdk@2001:bb6:3329:d100:c73:1525:4623:7479) (Quit: oisdk)
2021-02-22 01:28:38 +0100 <Axman6> can you include the error message please?
2021-02-22 01:28:48 +0100pfurla_(~pfurla@ool-182ed2e2.dyn.optonline.net) (Quit: gone to sleep. ZZZzzz…)
2021-02-22 01:29:21 +0100 <ski> ghais : the type of `cord1' is ambiguous
2021-02-22 01:29:55 +0100 <ghais> Axman6 sure one second.
2021-02-22 01:30:05 +0100 <ski> ghais : perhaps you intended for `cord1' to have the same type as `cord3' ?
2021-02-22 01:30:24 +0100 <ski> (also, s/Cartisian/Cartesian/ ?)
2021-02-22 01:30:25 +0100 <ghais> @ski why is the type ambiguous since it should have the same type as the constraint Ship s c
2021-02-22 01:30:25 +0100 <lambdabot> Maybe you meant: wiki src ask
2021-02-22 01:30:26 +0100 <Axman6> yeah there's no way to tewll which which impementation of fromCartesian you want, even though you've said Cartesian c
2021-02-22 01:31:00 +0100 <ghais> I thought it should be ultimately bound by the actual instance of Ship s c
2021-02-22 01:31:06 +0100 <ski> ghais : no. nothing prevents you from having multiple instances `Coordinate c' for different types `c'
2021-02-22 01:32:28 +0100 <ghais> @ski wouldn't adding explicit type to this then resolve it? Meaning if i were to say `cord1 = fromCartisian c : c`
2021-02-22 01:32:28 +0100 <lambdabot> Maybe you meant: wiki src ask
2021-02-22 01:32:31 +0100usr25(~usr25@unaffiliated/usr25) (Quit: Leaving)
2021-02-22 01:32:42 +0100 <Axman6> you have cord2 = toCartesian (fromCartesian c), which c is being passed between those two functions? It could be any
2021-02-22 01:32:48 +0100 <ski> ghais : `cord1' will have type `c0', for *some* type `c0' satisfying `Coordinate c0'. then `cord2' will use that same instance to translate back to `Cartesian'. then `cord3' will translate to a possibly different type `c1' (satisfying `Coordinate c1'). in fact this `c1' must be the `c' mentioned in the type of `sea'. but nothing prevents `c0' being a different type
2021-02-22 01:33:23 +0100 <ghais> @ski i understand, is there a way to tell the compiler then that these are the same type?
2021-02-22 01:33:23 +0100 <lambdabot> Maybe you meant: wiki src ask
2021-02-22 01:33:30 +0100 <Axman6> you probably want: sailShip :: forall s c. (Coordinate c, Ship s c) => Sea s c -> Name -> Cartisian -> Speed; ... cord1 = fromCartesian c :: c
2021-02-22 01:33:37 +0100 <ski> ghais : so, the problem is that nothing in your code informs `cord1 = fromCartesian c' and `cord2 = toCartesian cord1' which type `c0' to actually use
2021-02-22 01:33:38 +0100 <dolio> c_wraith: See, that's what I'm talking about with knowing the category theory context of monads. :)
2021-02-22 01:34:29 +0100 <ski> ghais : several ways. easiest is probably to put a type signature on `cord1', turn on `ScopedTypeVariables', and add `forall c s. ' to the signature of `sailShip'
2021-02-22 01:35:04 +0100 <ski> ghais : an alternative would be to define e.g. `[cord1,cord3] = [fromCartesian c,fromCartesian cord2]', since elements in the same list must have the same type
2021-02-22 01:35:26 +0100 <ghais> @ski i see. I think i get what the problem is now
2021-02-22 01:35:26 +0100 <lambdabot> Maybe you meant: wiki src ask
2021-02-22 01:35:38 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Quit: Free ZNC ~ Powered by LunarBNC: https://LunarBNC.net)
2021-02-22 01:35:42 +0100 <ghais> ski let me try the scoped typed variable approach
2021-02-22 01:36:04 +0100 <Axman6> ghais: on IRC, we tend to use <name>: not @<name>, and every time you do it you make lambdabot jump :)
2021-02-22 01:36:17 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:36:26 +0100jdsharp(~jdsharp@185.163.110.108)
2021-02-22 01:36:32 +0100 <ghais> Axman6, thanks for tip
2021-02-22 01:36:40 +0100 <ghais> sorry bot :)
2021-02-22 01:37:23 +0100 <ski> ghais : oh, and there's no need to adorn nicknames with sigils like `@' (it's not IRC custom to do so). if you want to refer to, or address, someone, simply mention their nickname. many IRC clients will alert/highlight the user if their nickname is mentioned, first thing in a message, but not as many will do it if it's mentioned later. putting a `@' before will prevent such alerts
2021-02-22 01:37:28 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-02-22 01:38:07 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:38:09 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-02-22 01:38:24 +0100 <ghais> ski, understood. Thank you both. I have only used IRC a couple of times before. I appreciate the help
2021-02-22 01:38:31 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr)
2021-02-22 01:39:09 +0100 <Axman6> Welcome!
2021-02-22 01:39:17 +0100 <ski> ghais : btw .. you could contemplate adding Functional Dependencies to `Ship'. also, `Sea' has a phantom parameter, is that really what you want to do. also, generally speaking, you should have at least two instances in mind, when you introduce a new type class. do you ?
2021-02-22 01:39:17 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-02-22 01:39:25 +0100star_cloud(~star_clou@ec2-34-220-44-120.us-west-2.compute.amazonaws.com) (Ping timeout: 240 seconds)
2021-02-22 01:39:41 +0100 <ski> beginners often go overboard with type classes, using them when there's no real reason to
2021-02-22 01:39:41 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:40:23 +0100 <ghais> ski, i do. I simplified the example here. The real use case is in https://github.com/ghais/hq/blob/main/src/Q/Options/ImpliedVol/Surface.hs#L111
2021-02-22 01:40:34 +0100 <ski> you probably don't want to make a type class, unless you're intending to define overloaded operations which in turn invoke methods of the type class (or other such overloaded operations)
2021-02-22 01:40:36 +0100nhs(~nhs@c-67-180-177-103.hsd1.ca.comcast.net) (Ping timeout: 240 seconds)
2021-02-22 01:40:38 +0100tmciver(~tmciver@cpe-172-101-40-226.maine.res.rr.com) (Ping timeout: 265 seconds)
2021-02-22 01:40:47 +0100 <monochrom> % 1+1
2021-02-22 01:40:48 +0100 <yahb> monochrom: 2
2021-02-22 01:41:17 +0100 <ghais> ski, i do. in the function above there are different instances of strike space that map to a cash strike
2021-02-22 01:41:19 +0100 <Axman6> Phew, glad that's still true, thanks monochrom
2021-02-22 01:42:10 +0100 <ski> i'd probably give a name to `slnShift surface'
2021-02-22 01:42:14 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-02-22 01:42:17 +0100tmciver(~tmciver@cpe-172-101-40-226.maine.res.rr.com)
2021-02-22 01:42:40 +0100 <ghais> ski, ah yeah probably a good idea
2021-02-22 01:43:15 +0100 <ski> `(TotalVar thetaT) = ...' can be just `TotalVar thetaT = ...'
2021-02-22 01:43:43 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:43:43 +0100juri_(~juri@178.63.35.222) (Ping timeout: 272 seconds)
2021-02-22 01:43:54 +0100 <ghais> ski, i worked around the problem here by adding the surface as an argument to cashToStrikeSpace and strikeSpaceToCash which seems to bind the variables, but i will try the other solution
2021-02-22 01:44:06 +0100 <ski> instead of `(t1, smile1) = fromJust $ ...', i'd probably use `Just (t1,smile1) = ...' (or maybe use `case')
2021-02-22 01:44:06 +0100 <ghais> ski, i didn't know that. Good to know
2021-02-22 01:44:24 +0100 <Axman6> Speaking of making bots jump, a friend of mine once wrote a slack bot for detecting if you'd ever written a haiku. It worked really well, apart from it being implemented as somerhing which called a C++ program via the command line. the way he'd done it was using "shell", so any text which included a ; would then cause anything following to be executed as another command. He only figured it out when he shee'd into the machine one day and found
2021-02-22 01:44:24 +0100 <Axman6> a few dozen isntances of vim running. We then realised we could just do things like "; ls /etc", "; cat /etc/passwd" etc. fun times
2021-02-22 01:44:30 +0100 <ski> (that will give a better error message, in case you happen to get `Nothing')
2021-02-22 01:44:31 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-02-22 01:44:39 +0100 <ghais> ski, In here, i handle the case of Maybe with surface extrapolation
2021-02-22 01:44:44 +0100 <ghais> of Nothing*
2021-02-22 01:44:51 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:45:12 +0100 <ghais> ski, but Just (t1, smile1) is really nice
2021-02-22 01:45:19 +0100 <ski> generally, it's good to (when reasonable) try to avoid partial operations like `fromJust',`head',`tail', ..
2021-02-22 01:45:33 +0100 <ghais> @ski makes sense. I will update it
2021-02-22 01:45:33 +0100 <lambdabot> Maybe you meant: wiki src ask
2021-02-22 01:45:37 +0100 <ghais> sorry
2021-02-22 01:45:58 +0100jedws(~jedws@101.184.202.248) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 01:46:28 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-02-22 01:46:47 +0100 <ski> can `surfaceType' only be `Normal' and `LogNormal' ?
2021-02-22 01:47:03 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:47:08 +0100fendor_(~fendor@178.165.129.166.wireless.dyn.drei.com)
2021-02-22 01:47:34 +0100 <ghais> and ShiftedLogNormal,
2021-02-22 01:47:40 +0100 <ski> ok
2021-02-22 01:47:48 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 01:47:51 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-02-22 01:47:51 +0100 <ski> you could factor out the common part of the two branches
2021-02-22 01:48:09 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec)
2021-02-22 01:48:16 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 01:48:25 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:48:27 +0100 <ghais> yeah makes sense
2021-02-22 01:48:45 +0100 <ski> volToTotalVar (euImpliedVol (if surfaceType == Normal then Normal else LogNormal) Call (Forward f) k11 t df premiumT) t
2021-02-22 01:48:55 +0100 <ski> (possibly naming that `if', if you prefer)
2021-02-22 01:49:05 +0100heatsink(~heatsink@2600:1700:bef1:5e10:2c3b:7c69:7266:b507) (Remote host closed the connection)
2021-02-22 01:49:23 +0100 <ghais> ski, i see. That makes sense i can name it in the function
2021-02-22 01:49:45 +0100fendor(~fendor@91.141.1.5.wireless.dyn.drei.com) (Ping timeout: 264 seconds)
2021-02-22 01:49:46 +0100 <ski> there's also some other repetitions that one could possibly factor out. it's not totally clear whether it would be worth it, but one could TIAS
2021-02-22 01:49:54 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-02-22 01:50:24 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:50:37 +0100skiwould probably use `where' instead of `let'-`in' .. but perhaps you prefer this ordering in this case
2021-02-22 01:50:55 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-22 01:51:00 +0100jcarpenter2(~rofl@96.78.87.197) (Ping timeout: 258 seconds)
2021-02-22 01:51:09 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-02-22 01:51:15 +0100 <ski> oh, and similarly, `(ShiftedLogNormal shift) -> shift' can be just `ShiftedLogNormal shift -> shift'
2021-02-22 01:51:17 +0100wagle(~wagle@quassel.wagle.io) (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
2021-02-22 01:51:32 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:51:40 +0100jrqc(~rofl@96.78.87.197)
2021-02-22 01:51:47 +0100wagle(~wagle@quassel.wagle.io)
2021-02-22 01:51:55 +0100 <ghais> ski, I normally would also use where, but in this case for the i felt the details is about time interpolation is what is important to read
2021-02-22 01:52:06 +0100skinods
2021-02-22 01:52:19 +0100 <ghais> ski, yeah i will update all of those. I didn't know that was possible
2021-02-22 01:52:45 +0100 <swarmcollective> ski, regarding "avoid partial operations like `fromJust',`head',`tail'", is there a pattern match for `init` or `last`? (xs: x) seems wrong.
2021-02-22 01:52:51 +0100 <ski> (personally i would also remove all or most uses of `$'. especially atrocities like `LogRel $ log $ k - f')
2021-02-22 01:53:08 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-02-22 01:53:11 +0100 <ghais> lol. Actually that is also a really good point
2021-02-22 01:53:15 +0100 <ghais> i will update that as well
2021-02-22 01:53:27 +0100 <Axman6> swarmcollective: no
2021-02-22 01:53:58 +0100 <ski> i guess one might make a pattern synonym
2021-02-22 01:54:00 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:54:05 +0100 <Axman6> but writing initAndTail isn't too hard; initAndTail [a] -> Maybe ([a],a)
2021-02-22 01:54:23 +0100conal(~conal@64.71.133.70)
2021-02-22 01:54:26 +0100 <Axman6> making it perform well takes a little bit of knowledge though
2021-02-22 01:54:39 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 01:54:53 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-02-22 01:54:57 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 01:55:24 +0100 <minoru_shiraeesh> Axman6: there is a way to make it perform well?
2021-02-22 01:55:42 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:55:57 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 01:55:58 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 01:56:13 +0100 <ski> % let Snoc xs x = "abcd" in (xs,x)
2021-02-22 01:56:13 +0100 <yahb> ski: ("abc",'d')
2021-02-22 01:56:19 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Client Quit)
2021-02-22 01:56:22 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 01:56:44 +0100 <ski> s/Tail/Last/
2021-02-22 01:56:46 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 01:56:49 +0100ddellacosta(~ddellacos@86.106.143.72)
2021-02-22 01:57:29 +0100 <Axman6> it would look something like: initAndTail [] = Nothing; initAndTail xs0 = Just (go xs0) where go [x] = ([],x); go (x:xs) = case go xs of ~(ys,t) -> (x:ys,t). I think that will make it appropriately lazy
2021-02-22 01:58:12 +0100poscat(~poscat@2408:8207:4825:b3e0::1) (Ping timeout: 260 seconds)
2021-02-22 01:59:06 +0100 <ski> `let' or `where' in place of that `case' will work just as well
2021-02-22 01:59:15 +0100 <ski> (no need for the irrefutable pattern then)
2021-02-22 01:59:27 +0100 <swarmcollective> % let Snoc xs x = "a" in (xs, x)
2021-02-22 01:59:28 +0100 <yahb> swarmcollective: ("",'a')
2021-02-22 01:59:29 +0100 <Axman6> hmm, really?
2021-02-22 01:59:40 +0100 <swarmcollective> % let Snoc xs x = "" in (xs, x)
2021-02-22 01:59:40 +0100 <yahb> swarmcollective: ("*** Exception: <interactive>:19:5-18: Non-exhaustive patterns in Snoc xs x
2021-02-22 02:00:38 +0100 <ski> % case "" of [] -> "oops"; Snoc xs x -> xs ++ "!" ++ [x]
2021-02-22 02:00:38 +0100 <yahb> ski: ; <interactive>:21:26: warning: [-Woverlapping-patterns]; Pattern match is redundant; In a case alternative: Snoc xs x -> ...; "oops"
2021-02-22 02:00:54 +0100ddellacosta(~ddellacos@86.106.143.72) (Ping timeout: 246 seconds)
2021-02-22 02:00:56 +0100 <ski> oh, fun
2021-02-22 02:01:45 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr) (Ping timeout: 264 seconds)
2021-02-22 02:01:48 +0100 <Axman6> % let xs = Snoc "abc" 'd' in xs
2021-02-22 02:01:49 +0100 <yahb> Axman6: "abcd"
2021-02-22 02:01:51 +0100 <minoru_shiraeesh> Axman6, "I think that will make it appropriately lazy" is it because of a tilde?
2021-02-22 02:01:54 +0100 <Axman6> great
2021-02-22 02:02:03 +0100average(uid473595@gateway/web/irccloud.com/x-vjticfovgmrwoddf) (Quit: Connection closed for inactivity)
2021-02-22 02:02:06 +0100 <ski> % case "" of Nil -> "oops"; Snoc xs x -> xs ++ "!" ++ [x]
2021-02-22 02:02:06 +0100 <yahb> ski: "oops"
2021-02-22 02:02:08 +0100 <Axman6> minoru_shiraeesh: yes, thought apparently that isn't necessary
2021-02-22 02:02:10 +0100 <ski> % case "abcd" of Nil -> "oops"; Snoc xs x -> xs ++ "!" ++ [x]
2021-02-22 02:02:11 +0100 <yahb> ski: "abc!d"
2021-02-22 02:02:12 +0100 <ski> there
2021-02-22 02:02:18 +0100 <swarmcollective> Interesting! Axman6, I'll pull this into a repl.
2021-02-22 02:02:20 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 02:02:36 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 02:02:53 +0100 <ski> the `~' is necessary, if using the `case'
2021-02-22 02:03:24 +0100 <monochrom> "let" adds an implicit ~
2021-02-22 02:03:34 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-22 02:03:34 +0100 <minoru_shiraeesh> I don't know what that tilde is doing (and how this technique is called), but it seems like without it the function becomes linear-time
2021-02-22 02:03:36 +0100 <Axman6> I guess it makes sense that patterns in let and where are irrefutable by default
2021-02-22 02:03:46 +0100 <Axman6> I'd never thought of that, TIL
2021-02-22 02:03:54 +0100 <monochrom> "let (_,_) = foo in ()" = "case foo of ~(_,_) -> ()"
2021-02-22 02:04:33 +0100 <monochrom> Therefore, to a very, very large extent, you can treat ! as the opposite of ~
2021-02-22 02:04:34 +0100 <ghais> ski, scoped type variables fixed it. I understand what caused it in the first place and i understand the solution. Thank you very much
2021-02-22 02:04:51 +0100 <monochrom> "let !(_,_) = foo in ()" = "case foo of (_,_) -> ()"
2021-02-22 02:04:52 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 02:04:54 +0100jedws(~jedws@101.184.202.248)
2021-02-22 02:04:56 +0100 <ghais> ski, can i also use type application here?
2021-02-22 02:05:00 +0100jollygood2(~bc8134e3@217.29.117.252) (Quit: quit)
2021-02-22 02:05:03 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec)
2021-02-22 02:06:19 +0100 <Axman6> yes
2021-02-22 02:06:30 +0100 <Axman6> you could have written fromCartesian @c c
2021-02-22 02:06:58 +0100 <ghais> Axman6, i think that might cleaner that adding ::c at the end of the line
2021-02-22 02:07:05 +0100 <ski> minoru_shiraeesh : without it, it won't work on infinite lists, yes
2021-02-22 02:07:09 +0100 <minoru_shiraeesh> ghais: can you post a snippet with a working code?
2021-02-22 02:07:24 +0100 <Axman6> I agree, but it's a slightly more advanced way of doing it
2021-02-22 02:07:30 +0100 <ski> Axman6 : i might use `fmap' in practice
2021-02-22 02:07:34 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 260 seconds)
2021-02-22 02:08:02 +0100 <ski> ghais : "adding ::c at the end of the line" is not "adding a signature", btw
2021-02-22 02:08:52 +0100 <ghais> minoru_shiraeesh, yeah i updated the full code instead of the small example. I will update the small example. one sec
2021-02-22 02:09:03 +0100 <minoru_shiraeesh> thanks
2021-02-22 02:09:05 +0100 <ghais> ski, what do you mean?
2021-02-22 02:09:05 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Ping timeout: 240 seconds)
2021-02-22 02:09:53 +0100oisdk(~oisdk@2001:bb6:3329:d100:c73:1525:4623:7479)
2021-02-22 02:10:25 +0100 <ski> i mean that doing
2021-02-22 02:10:40 +0100 <ski> cord1 = fromCartesian c :: c
2021-02-22 02:10:52 +0100 <ski> is using a type ascription, but doing
2021-02-22 02:10:56 +0100 <ski> cord1 :: c
2021-02-22 02:10:59 +0100 <ski> cord1 = fromCartesian c
2021-02-22 02:11:02 +0100 <ski> is using a type signature
2021-02-22 02:11:32 +0100 <ghais> ski, i see
2021-02-22 02:11:49 +0100 <ghais> minoru_shiraeesh, i updated the example here https://gist.github.com/ghais/2911a582d712a4cafe244b826654cdab
2021-02-22 02:12:07 +0100 <ghais> minoru_shiraeesh, not the type ascription at the end of 21 and 23
2021-02-22 02:12:18 +0100 <ghais> minoru_shiraeesh also the scoped type param pragma at the top
2021-02-22 02:12:26 +0100 <ghais> i also fixed a bug in the type of Sea
2021-02-22 02:12:46 +0100 <ghais> type of Sea.ships i mean
2021-02-22 02:13:13 +0100 <ski> (some people are not aware that you can put type signatures in `where' and `let')
2021-02-22 02:13:35 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-axacivxcvkkvhqtx)
2021-02-22 02:13:42 +0100 <ghais> minoru_shiraeesh, you will need a few more pragmas i think to make the example compile, RecordWildCards for example
2021-02-22 02:14:24 +0100 <ghais> I will probably fix the typo as well :)
2021-02-22 02:15:56 +0100 <ski> (btw the type of `cord3' is already inferred to be the `c' in the signature of `sailShip', since you pass it to `sail' along with `ship' coming from `ships', whose type involve `c'
2021-02-22 02:15:58 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:b8ec:ecd4:c92c:f02:3202) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 02:16:21 +0100 <ski> (oh, and i think usually people abbreviate "coordinate" as "coord" rather that "cord")
2021-02-22 02:16:27 +0100 <ghais> yeah makes sense
2021-02-22 02:16:28 +0100 <ski> @wn cord
2021-02-22 02:16:28 +0100 <lambdabot> *** "cord" wn "WordNet (r) 3.0 (2006)"
2021-02-22 02:16:28 +0100 <lambdabot> cord
2021-02-22 02:16:28 +0100 <lambdabot> n 1: a line made of twisted fibers or threads; "the bundle was
2021-02-22 02:16:28 +0100 <lambdabot> tied with a cord"
2021-02-22 02:16:28 +0100 <lambdabot> 2: a unit of amount of wood cut for burning; 128 cubic feet
2021-02-22 02:16:30 +0100 <lambdabot> [6 @more lines]
2021-02-22 02:17:01 +0100Tario(~Tario@201.192.165.173) (Read error: Connection reset by peer)
2021-02-22 02:17:04 +0100 <swarmcollective> Cool use of WordNet! Nice.
2021-02-22 02:17:45 +0100 <swarmcollective> Is this @wn plugin new? Is it on github? (I'll go look)
2021-02-22 02:17:58 +0100 <ski> not new
2021-02-22 02:18:09 +0100 <ski> @list dict
2021-02-22 02:18:09 +0100 <lambdabot> dict provides: dict-help all-dicts bouvier cide devils easton elements foldoc gazetteer hitchcock jargon thesaurus vera wn world02
2021-02-22 02:18:13 +0100geowiesnot(~user@87-89-181-157.abo.bbox.fr)
2021-02-22 02:18:32 +0100 <monochrom> . o O ( https://en.wikipedia.org/wiki/CORDIC so "cord" can be OK if you add "ic" after it >:) )
2021-02-22 02:19:01 +0100 <swarmcollective> ski, thanks!
2021-02-22 02:19:01 +0100ski. o O ( that's cordial )
2021-02-22 02:19:09 +0100 <monochrom> haha
2021-02-22 02:19:15 +0100 <monochrom> or rather....
2021-02-22 02:19:20 +0100 <monochrom> . o O ( haha )
2021-02-22 02:19:28 +0100 <minoru_shiraeesh> ghais, thanks
2021-02-22 02:19:34 +0100 <ephemient> as long as you don't abbreviate it to "chord"... that would be evil
2021-02-22 02:19:36 +0100 <ski> yw
2021-02-22 02:19:41 +0100 <ghais> np
2021-02-22 02:20:07 +0100 <ghais> monochrom, this is actually a real nice algorithm. Thanks for sharing that
2021-02-22 02:21:09 +0100heatsink(~heatsink@2600:1700:bef1:5e10:2c3b:7c69:7266:b507)
2021-02-22 02:22:09 +0100 <ghais> similar works was done by Henry Briggs. I know one of his descends :) he works in quantitative finance as well
2021-02-22 02:22:11 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 02:22:11 +0100Tops21(~Tobias@dyndsl-095-033-094-064.ewe-ip-backbone.de)
2021-02-22 02:22:35 +0100 <monochrom> neat
2021-02-22 02:22:43 +0100 <dolio> Whoever was teaching acronyms back in the 50s should have been fired.
2021-02-22 02:22:59 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 02:23:07 +0100 <monochrom> I don't think today is any better.
2021-02-22 02:23:19 +0100 <ghais> proof in my example: cord
2021-02-22 02:23:45 +0100 <dolio> Yours isn't an acronym, I think.
2021-02-22 02:23:53 +0100 <ghais> right
2021-02-22 02:24:07 +0100mirrorbird(~psutcliff@2a00:801:446:6dfc:fadb:e310:6ed2:16d) (Quit: Leaving)
2021-02-22 02:25:16 +0100Tops2(~Tobias@dyndsl-095-033-094-064.ewe-ip-backbone.de) (Ping timeout: 240 seconds)
2021-02-22 02:25:27 +0100Tario(~Tario@201.192.165.173)
2021-02-22 02:26:00 +0100ski. o O ( Cordwainer Smith )
2021-02-22 02:27:25 +0100cabled(4c4829bb@76.72.41.187)
2021-02-22 02:28:16 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 02:30:00 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 02:31:05 +0100gzj(~gzj@unaffiliated/gzj) (Remote host closed the connection)
2021-02-22 02:31:26 +0100gzj(~gzj@unaffiliated/gzj)
2021-02-22 02:31:28 +0100 <minoru_shiraeesh> so, to clarify: is there a way to make init and tail operations on list constant-time?
2021-02-22 02:31:36 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 02:34:18 +0100cabled(4c4829bb@76.72.41.187) (Quit: Connection closed)
2021-02-22 02:34:25 +0100 <edwardk> minoru_shiraeesh: yes, but at the cost of the laziness of the list
2021-02-22 02:34:37 +0100 <edwardk> minoru_shiraeesh: you can use an okasaki style double ended queue structure
2021-02-22 02:34:52 +0100 <edwardk> and get O(1) access to both ends
2021-02-22 02:35:00 +0100 <edwardk> you can also use Data.Sequence which is available out of the box
2021-02-22 02:35:24 +0100 <edwardk> Data.Sequence gives O(1) access to both ends, and offers log time indexing and a whole bunch of other operations
2021-02-22 02:35:31 +0100 <edwardk> the constants are worse though
2021-02-22 02:36:09 +0100 <minoru_shiraeesh> edwardk: "yes, but at the cost of the laziness of the list" - how?
2021-02-22 02:36:23 +0100 <edwardk> import Data.Sequence. use it instead. done.
2021-02-22 02:36:50 +0100 <edwardk> if you want the details. you can read the fingertree paper by hinze and paterson
2021-02-22 02:36:56 +0100ghais(4c616ae2@gateway/web/cgi-irc/kiwiirc.com/ip.76.97.106.226) (Ping timeout: 240 seconds)
2021-02-22 02:37:05 +0100gzj(~gzj@unaffiliated/gzj) (Remote host closed the connection)
2021-02-22 02:37:10 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:e027:ed4b:9a92:9af6) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 02:37:12 +0100 <ski> minoru_shiraeesh : sure, define `data Tsil a = Nil | Snoc (Tsil a) a'
2021-02-22 02:37:15 +0100 <edwardk> there's also a book on 'purely functional data structures' by okasaki that offers about 4-5 different constructions for double-ended queues that have O(1) access to either end.
2021-02-22 02:37:30 +0100gzj(~gzj@unaffiliated/gzj)
2021-02-22 02:37:34 +0100 <edwardk> ski's solution works if you only want access to the tail and not the head, as well ;)
2021-02-22 02:37:48 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 02:38:04 +0100nullniv73(~null@unaffiliated/nullniverse)
2021-02-22 02:38:09 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-02-22 02:38:13 +0100skiusually refers to that as the "folklore queue"
2021-02-22 02:38:16 +0100 <edwardk> but the fingertree and okasaki solutions give real O(1) access to both ends (most of them are amortized, but the 'real-time deque' options in okasaki are worst-case bounded O(1))
2021-02-22 02:38:28 +0100nullniverse(~null@unaffiliated/nullniverse) (Read error: No route to host)
2021-02-22 02:38:30 +0100nullniv73(~null@unaffiliated/nullniverse) (Read error: Connection reset by peer)
2021-02-22 02:38:31 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr)
2021-02-22 02:38:44 +0100 <ski> PFDS is good
2021-02-22 02:38:45 +0100nullniverse(~null@unaffiliated/nullniverse)
2021-02-22 02:39:18 +0100 <edwardk> oooh, unlifted fingertrees. man i'm going to have to take this project and split it apart into multiple libraries or start treating the current lib as unlifted:base and add more sublibs!
2021-02-22 02:39:27 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 02:39:36 +0100da39a3ee5e6b4b0d(~da39a3ee5@184.22.159.161)
2021-02-22 02:41:05 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec)
2021-02-22 02:41:41 +0100 <minoru_shiraeesh> I mean, once you got a list, you're stuck with linear-time init and last. I imagined something like changing low-level representation (like creating an ad-hoc array under the hood for example), some low-level loophole like that.
2021-02-22 02:41:43 +0100TMA(tma@twin.jikos.cz) (Ping timeout: 256 seconds)
2021-02-22 02:41:45 +0100geowiesnot(~user@87-89-181-157.abo.bbox.fr) (Ping timeout: 240 seconds)
2021-02-22 02:41:56 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 02:42:06 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 02:42:14 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de)
2021-02-22 02:42:28 +0100fengh(~haskeller@ip72-205-40-121.dc.dc.cox.net)
2021-02-22 02:42:41 +0100 <dolio> If you want fast init/last, you use something other than a list.
2021-02-22 02:42:48 +0100sz0(uid110435@gateway/web/irccloud.com/x-ybsyrtlqvchdhgkr) (Quit: Connection closed for inactivity)
2021-02-22 02:43:37 +0100 <swarmcollective> Or invert the list and use `head` and `tail` :D
2021-02-22 02:43:38 +0100Tario(~Tario@201.192.165.173) (Read error: Connection reset by peer)
2021-02-22 02:43:47 +0100 <dolio> Yeah, that's another possibility.
2021-02-22 02:44:46 +0100Tario(~Tario@201.192.165.173)
2021-02-22 02:46:14 +0100 <dolio> At least, something other than the things that are called "lists" in Haskell.
2021-02-22 02:46:20 +0100 <EvanR> if you only need one side of a list, you basically are dealing with a stack
2021-02-22 02:48:12 +0100qsc(72f2f943@114.242.249.67)
2021-02-22 02:48:49 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 02:49:02 +0100qsc(72f2f943@114.242.249.67) (Client Quit)
2021-02-22 02:49:22 +0100heatsink(~heatsink@2600:1700:bef1:5e10:2c3b:7c69:7266:b507) (Remote host closed the connection)
2021-02-22 02:49:48 +0100rajivr(uid269651@gateway/web/irccloud.com/x-yvjuawdfkidfnsxx)
2021-02-22 02:49:49 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 02:49:55 +0100ddellacosta(~ddellacos@86.106.143.111)
2021-02-22 02:50:49 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:7ce7:fe06:1dad:4fcd)
2021-02-22 02:51:30 +0100m_miro(4c4829bb@76.72.41.187)
2021-02-22 02:52:02 +0100 <m_miro> excuse me could someone help me figure out whats wrong with my function?
2021-02-22 02:53:16 +0100 <ddellacosta> m_miro: got a gist or something?
2021-02-22 02:53:22 +0100 <m_miro> I'm trying to write a function that takes a list of tuples and returns the first element of a tuple if the second element is the greatest of all the second elements in the tuple.
2021-02-22 02:53:34 +0100 <m_miro> Let me pastebin it
2021-02-22 02:54:08 +0100 <EvanR> and what happens if there are multiple maximums
2021-02-22 02:54:27 +0100 <ski> @where paste
2021-02-22 02:54:27 +0100 <lambdabot> Help us help you: please paste full code, input and/or output at e.g. https://paste.tomsmeding.com
2021-02-22 02:55:11 +0100pjb(~t@2a01cb04063ec5000d634482ebf2e83c.ipv6.abo.wanadoo.fr) (Ping timeout: 272 seconds)
2021-02-22 02:55:29 +0100rayyyy(~nanoz@gateway/tor-sasl/nanoz)
2021-02-22 02:56:05 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-22 02:56:27 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 256 seconds)
2021-02-22 02:56:28 +0100 <m_miro> heres the functionhttps://paste.tomsmeding.com/gN7hHFj5
2021-02-22 02:56:34 +0100 <m_miro> heres the function https://paste.tomsmeding.com/gN7hHFj5
2021-02-22 02:57:15 +0100 <ski> you probably meant `foldr (...) (head xs) (tail xs)'
2021-02-22 02:57:37 +0100 <ski> `fst(x)' can be just `fst x'. similarly for `snd'
2021-02-22 02:58:34 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-22 02:59:05 +0100 <m_miro> adding parenthesis around head xs and tail xs results in an error
2021-02-22 02:59:14 +0100 <ski> yes, you have a type error, still
2021-02-22 02:59:22 +0100 <ski> what is the result of that `foldr' call ?
2021-02-22 03:00:02 +0100 <m_miro> the result of the foldr call is a tuple
2021-02-22 03:00:08 +0100 <ski> a pair, yes
2021-02-22 03:00:13 +0100 <m_miro> oh snap
2021-02-22 03:00:22 +0100 <ski> heh, you just realized it, i think :)
2021-02-22 03:00:24 +0100 <m_miro> I need a fst around that foldr call
2021-02-22 03:00:28 +0100 <ski> yes
2021-02-22 03:00:43 +0100 <m_miro> '=D thanks ski
2021-02-22 03:00:57 +0100 <ski> what would happen if `tail xs' is empty ?
2021-02-22 03:01:43 +0100 <m_miro> I don't know, I think it would result in an error
2021-02-22 03:02:08 +0100 <ski> try it, in the interactor ?
2021-02-22 03:02:18 +0100 <ski> or try looking at the definition of `foldr', possibly ?
2021-02-22 03:02:19 +0100heatsink(~heatsink@2600:1700:bef1:5e10:2c3b:7c69:7266:b507)
2021-02-22 03:02:22 +0100 <ski> @src foldr
2021-02-22 03:02:22 +0100 <lambdabot> foldr f z [] = z
2021-02-22 03:02:22 +0100 <lambdabot> foldr f z (x:xs) = f x (foldr f z xs)
2021-02-22 03:03:16 +0100elliott_(~elliott_@pool-108-51-101-42.washdc.fios.verizon.net) (Ping timeout: 240 seconds)
2021-02-22 03:03:27 +0100 <m_miro> so if the tail is empty it chooses z instead?
2021-02-22 03:03:57 +0100 <ski> yes
2021-02-22 03:04:13 +0100 <ski> > foldr f z [a,b,c,d]
2021-02-22 03:04:15 +0100 <lambdabot> f a (f b (f c (f d z)))
2021-02-22 03:04:23 +0100 <ski> > foldr f z [a]
2021-02-22 03:04:25 +0100 <lambdabot> f a z
2021-02-22 03:04:27 +0100 <ski> > foldr f z []
2021-02-22 03:04:28 +0100 <lambdabot> z
2021-02-22 03:04:56 +0100elliott_(~elliott_@pool-108-51-101-42.washdc.fios.verizon.net)
2021-02-22 03:05:07 +0100 <ski> what is the consequence of this, for your code ?
2021-02-22 03:05:30 +0100 <m_miro> is it possible that z isn't the greatest value?
2021-02-22 03:05:42 +0100jamm_(~jamm@unaffiliated/jamm)
2021-02-22 03:06:11 +0100 <ski> if `xs' is `[z]', then `head xs' is `z' and `tail xs' is `[]'. so the result of the `foldr' call will be `z'
2021-02-22 03:06:26 +0100 <ski> if the list has only one element, then that is the greatest value
2021-02-22 03:08:05 +0100gzj(~gzj@unaffiliated/gzj) (Remote host closed the connection)
2021-02-22 03:08:06 +0100 <m_miro> so it still results in the greatest value being return
2021-02-22 03:08:14 +0100 <ski> yes
2021-02-22 03:08:18 +0100 <ski> and so .. ?
2021-02-22 03:08:25 +0100gzj(~gzj@unaffiliated/gzj)
2021-02-22 03:09:09 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 03:09:13 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net)
2021-02-22 03:10:14 +0100jamm_(~jamm@unaffiliated/jamm) (Ping timeout: 264 seconds)
2021-02-22 03:10:35 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 03:11:07 +0100xff0x(~xff0x@2001:1a81:52c4:2f00:fa7c:56b7:c532:c584) (Ping timeout: 260 seconds)
2021-02-22 03:11:23 +0100mirrorbird(~psutcliff@2a00:801:446:6dfc:fadb:e310:6ed2:16d)
2021-02-22 03:11:57 +0100 <m_miro> so I don't need the first greatestPair pattern?
2021-02-22 03:12:01 +0100bitmapper(uid464869@gateway/web/irccloud.com/x-uhoorvvzjdpjkavt) (Quit: Connection closed for inactivity)
2021-02-22 03:12:30 +0100xff0x(~xff0x@2001:1a81:52fd:ec00:d491:9747:a76e:961a)
2021-02-22 03:13:15 +0100 <ski> right, the first defining equation is redundant, that case is already correctly covered by the general case
2021-02-22 03:15:01 +0100 <ski> m_miro : oh. you also don't need the brackets in `greatestPair (xs) = ...'
2021-02-22 03:15:23 +0100 <ski> nor do you need to wrap the list in extra brackets, in `main'
2021-02-22 03:16:09 +0100 <m_miro> ok I'll get delete the first equation then
2021-02-22 03:16:20 +0100 <m_miro> and all the extra brackets
2021-02-22 03:16:33 +0100 <edwardk> minoru_shiraeesh: https://www.irccloud.com/pastebin/FWp4VlDt/RealtimeDeque.hs provides constant time access to either end.
2021-02-22 03:16:48 +0100tmciver(~tmciver@cpe-172-101-40-226.maine.res.rr.com) (Read error: Connection reset by peer)
2021-02-22 03:16:48 +0100 <zzz> how should I generally approach choosing the best whatever library? I was doing something with Data.Graph and have just been told that it's a weak, limited and outdated module. This seems to happen a lot
2021-02-22 03:17:09 +0100 <edwardk> you can use (:>) to snoc, init/last and (:<) to cons/head/tail
2021-02-22 03:17:35 +0100 <edwardk> length is also O(1)
2021-02-22 03:17:54 +0100 <ski> m_miro : it often makes sense to ponder whether one could use simpler base cases, and whether some cases are already correctly handled by other cases (or can be reasonably made to do so)
2021-02-22 03:17:56 +0100 <edwardk> adding all the list instances, etc.? on you.
2021-02-22 03:18:03 +0100shatriff(~vitaliish@protective.remission.volia.net) (Remote host closed the connection)
2021-02-22 03:18:19 +0100shatriff(~vitaliish@protective.remission.volia.net)
2021-02-22 03:18:23 +0100 <ski> m_miro : this helps to make code more intelligible. "DRY" - "Don't Repeat Yourself"
2021-02-22 03:18:48 +0100shatriff(~vitaliish@protective.remission.volia.net) (Remote host closed the connection)
2021-02-22 03:19:11 +0100jamm_(~jamm@unaffiliated/jamm)
2021-02-22 03:19:27 +0100anselmschueler(2e72278d@dynamic-046-114-039-141.46.114.pool.telefonica.de)
2021-02-22 03:19:29 +0100 <ski> (in this case, `greatestPair' doesn't make sense, in case the list is empty. but often, empty or trivial cases will make sense, even if one often initially doesn't think so. it commonly pays off to allow them then, even if they don't appear to be useful, at first sight)
2021-02-22 03:19:37 +0100shatriff(~vitaliish@protective.remission.volia.net)
2021-02-22 03:19:41 +0100anselmschueler(2e72278d@dynamic-046-114-039-141.46.114.pool.telefonica.de) (Client Quit)
2021-02-22 03:19:52 +0100 <edwardk> zzz: Data.Graph is pretty simple and if what you want can be done with it its perfectly fine. I had to roll my own version of a couple of its algorithms in the 'ad' package. There's several other graph libraries out there, each has a different flavor. I wrote one for a particular style of graph. https://hackage.haskell.org/package/fgl is probably the most robust
2021-02-22 03:20:07 +0100anselm-d-schuele(2e72278d@dynamic-046-114-039-141.46.114.pool.telefonica.de)
2021-02-22 03:20:17 +0100anselm-d-schuele(2e72278d@dynamic-046-114-039-141.46.114.pool.telefonica.de) (Client Quit)
2021-02-22 03:20:37 +0100anselmschueler(2e72278d@dynamic-046-114-039-141.46.114.pool.telefonica.de)
2021-02-22 03:20:40 +0100 <edwardk> zzz: hopefully the docs indicate intended scope. i dont think its possible to write one package that is one-size fits all for graphs, erwig's fgl library is the closest i know.
2021-02-22 03:21:56 +0100 <edwardk> minoru_shiraeesh: To your "use an array or something" point, Data.Vector does that and also gives you fast O(1) init/last, but it costs O(n) to snoc or cons.
2021-02-22 03:22:01 +0100 <m_miro> I'll to keep that in mind as I make more functions ski
2021-02-22 03:22:04 +0100Tops21(~Tobias@dyndsl-095-033-094-064.ewe-ip-backbone.de) (Read error: Connection reset by peer)
2021-02-22 03:22:29 +0100 <anselmschueler> Hey, I have a question about linear types
2021-02-22 03:22:40 +0100 <anselmschueler> or, tangentially related to it
2021-02-22 03:22:54 +0100 <edwardk> you can steel-man it into an approach that uses a logarithmic number of arrays, flat arrays but that only gets you log time cons/index. which isn't actually any better than can be done without arrays
2021-02-22 03:23:00 +0100 <edwardk> anselmschueler: shoot
2021-02-22 03:23:08 +0100 <ski> m_miro : some very basic examples of this is `sum',`product',`and',`or'
2021-02-22 03:23:10 +0100 <edwardk> i've been obsessed about them this week =)
2021-02-22 03:23:26 +0100jamm_(~jamm@unaffiliated/jamm) (Ping timeout: 240 seconds)
2021-02-22 03:23:26 +0100deviantfero(~deviantfe@190.150.27.58)
2021-02-22 03:23:38 +0100 <anselmschueler> I've recently watched SPJ's talk [https://www.youtube.com/watch?v=t0mhvd3-60Y](https://www.youtube.com/watch?v=t0mhvd3-60Y)
2021-02-22 03:23:55 +0100 <anselmschueler> oh shoot
2021-02-22 03:24:00 +0100 <anselmschueler> did I mess up the link format?
2021-02-22 03:24:10 +0100 <anselmschueler> is it [alt](url) or (url)[alt]
2021-02-22 03:24:11 +0100 <dolio> IRC is text.
2021-02-22 03:24:11 +0100 <ski> (it did look weird)
2021-02-22 03:24:12 +0100 <edwardk> all good
2021-02-22 03:24:17 +0100stree(~stree@68.36.8.116) (Ping timeout: 256 seconds)
2021-02-22 03:24:25 +0100 <edwardk> irc is just text, so just link, we figured it out =)
2021-02-22 03:24:29 +0100 <anselmschueler> dolio I'm on freenode
2021-02-22 03:24:34 +0100 <anselmschueler> so they format the text
2021-02-22 03:24:43 +0100 <ski> we're all on Freenode, here
2021-02-22 03:24:57 +0100 <anselmschueler> can't you connect using a 3p IRC client
2021-02-22 03:25:02 +0100 <ski> (but many of us aren't using the Freenode webchat)
2021-02-22 03:25:24 +0100 <edwardk> anselmschueler: your q?
2021-02-22 03:25:51 +0100 <anselmschueler> So I've recently watched that talk, and I'm confused by "mutable arrays". They're mutable arrays *in the context of a state monad*, right?
2021-02-22 03:25:54 +0100 <yushyin> (freenode is the name of the irc network and there is no first-party client)
2021-02-22 03:26:22 +0100 <anselmschueler> 'cause all values are strictly immutable in Haskell, right?
2021-02-22 03:26:34 +0100 <edwardk> i can allocate a 'mutable array' and if you have the only reference to the evil mutable array, you can change it and give it back, rather than copy it with one element changed and give it back
2021-02-22 03:26:36 +0100 <anselmschueler> so the only way for mutability to arise is by some state management
2021-02-22 03:26:38 +0100 <minoru_shiraeesh> edwardk: thanks for clarification
2021-02-22 03:26:41 +0100 <edwardk> and nobody can care
2021-02-22 03:26:48 +0100 <dolio> If they're linear, then the same sort of API for an immutable array can be implemented by mutating.
2021-02-22 03:27:08 +0100 <zzz> thanks edwardk
2021-02-22 03:27:09 +0100ski. o O ( unique )
2021-02-22 03:27:24 +0100 <anselmschueler> how can I change it and give it back? or is this in the context of unsafe/impure FFI stuff?
2021-02-22 03:27:25 +0100 <dolio> Yeah, but SPJ isn't talking about uniqueness types.
2021-02-22 03:27:42 +0100 <anselmschueler> (I've never used the FFI)
2021-02-22 03:28:07 +0100 <edwardk> anselmschueler: linear-base does evil things behind the scenes but exposes a 'safe' Array type that does mutation, the same way that ST s provides 'safe' array operations that are mutable
2021-02-22 03:28:21 +0100 <edwardk> here instead of the quantifier for the ST s monad controlling access it is uniqueness of reference to the array
2021-02-22 03:28:26 +0100 <dolio> Actually, I guess the API would be slightly different, because reading would require yielding a new array.
2021-02-22 03:28:39 +0100 <anselmschueler> how does it do that? isn't that impossible in Haskell?
2021-02-22 03:29:01 +0100 <edwardk> alloc :: Int -> a -> (Array a %1 -> Ur b) %1 -> Ur b -- manufactures the array.
2021-02-22 03:29:07 +0100m_miro(4c4829bb@76.72.41.187) (Quit: Connection closed)
2021-02-22 03:29:29 +0100 <edwardk> set :: HasCallStack => Int -> a -> Array a %1 -> Array a
2021-02-22 03:29:33 +0100 <edwardk> notice the funny %1's
2021-02-22 03:29:39 +0100 <edwardk> that is the new superpower that linear haskell gives us
2021-02-22 03:29:43 +0100 <anselmschueler> OK I need to clarify: I'm not actually talking about linear types — that's just the context where I heard of this.
2021-02-22 03:29:43 +0100 <anselmschueler> I'm asking about *mutable arrays*
2021-02-22 03:29:57 +0100 <anselmschueler> what the hell are mutable arrays & how TF are they possible in haskell
2021-02-22 03:29:59 +0100 <edwardk> let's look at haskell's mutable array story
2021-02-22 03:30:00 +0100 <ski> are you asking about `IOArray'/`STArray' ?
2021-02-22 03:30:13 +0100 <anselmschueler> ski I don't know, I've never used them
2021-02-22 03:30:27 +0100 <anselmschueler> I just know that they apparently exist, from that takl
2021-02-22 03:30:30 +0100 <anselmschueler> *talk
2021-02-22 03:30:34 +0100 <edwardk> we have IOArray and STArray s, both of which are implemented on top of an MutableArray# primitive defined in GHC.Prim
2021-02-22 03:30:49 +0100 <edwardk> both of which expose an IO or ST s based API for working with them
2021-02-22 03:30:58 +0100 <anselmschueler> ok but how does MutableArray# work
2021-02-22 03:31:03 +0100 <anselmschueler> how can the array be mutable
2021-02-22 03:31:09 +0100 <anselmschueler> or is it a pointer to a mutable array
2021-02-22 03:31:12 +0100 <edwardk> ok, are you familiar with how IO is treated internally in haskell?
2021-02-22 03:31:18 +0100 <anselmschueler> nope, not at all!
2021-02-22 03:31:32 +0100 <ski> an `IOArray i e' is a reference (think "identifier"/"index"/"name") of a mutable array. the mutable array itself is kept (conceptually passed around), inside `IO' (not the `IOArray')
2021-02-22 03:31:33 +0100 <edwardk> MutableArray# is literally a direct pointer to a mutable object that lives on the heap and holds n elements of type a
2021-02-22 03:31:43 +0100 <edwardk> ok, let's squint under the hood of IO
2021-02-22 03:31:48 +0100pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net)
2021-02-22 03:32:01 +0100 <edwardk> newtype IO a = IO { runIO :: State# RealWorld -> (# State# RealWorld, a #) }
2021-02-22 03:32:04 +0100 <anselmschueler> sorry if I'm being dumb btw
2021-02-22 03:32:05 +0100 <edwardk> that is scary loking stuff
2021-02-22 03:32:07 +0100 <edwardk> no worries
2021-02-22 03:32:12 +0100 <edwardk> we all have to find this stuff out somehow
2021-02-22 03:32:41 +0100 <anselmschueler> > newtype IO a = ...
2021-02-22 03:32:41 +0100 <anselmschueler> oh yeeah I saw that somewhere
2021-02-22 03:32:42 +0100 <lambdabot> <hint>:1:1: error:
2021-02-22 03:32:42 +0100 <lambdabot> <hint>:1:1: error: parse error on input ‘newtype’
2021-02-22 03:32:48 +0100 <edwardk> What is a State# RealWorld? well, that is a token representing 'passing the universe'.
2021-02-22 03:32:48 +0100 <ski> conceptually, an `IOArray i e' is like an array index, or a `Map' key. it doesn't itself contain the data. it only allows you to access the data, when you're separately provided with it (under the covers of `IO', conceptually)
2021-02-22 03:33:04 +0100 <edwardk> an operation takes a state of the real world, and gives back an updated real world, and a value of type a.
2021-02-22 03:33:08 +0100 <edwardk> this looks a lot like the state monad
2021-02-22 03:33:18 +0100 <anselmschueler> `(# a, b #)` is an unboxed tuple right?
2021-02-22 03:33:21 +0100 <edwardk> the (# #) rather than ( ) for the tuple says that is an unboxed tuple
2021-02-22 03:33:21 +0100 <edwardk> yeah
2021-02-22 03:33:27 +0100gzj(~gzj@unaffiliated/gzj) (Remote host closed the connection)
2021-02-22 03:33:46 +0100gzj(~gzj@unaffiliated/gzj)
2021-02-22 03:33:56 +0100 <edwardk> that is a pair of things, rather than a pointer to a heap object that is a pair of things liek the usual (). State# isn't in kind Type, so you can't pass it directly in a normal (,)
2021-02-22 03:34:16 +0100 <edwardk> State# s takes zero bytes to store
2021-02-22 03:34:31 +0100 <edwardk> its just a kind of formal tag that shows up in the type
2021-02-22 03:34:39 +0100 <ski> (you could think of `State# RealWorld' as including a `Map' from `IOArray's (and `IORef's) to the actual corresponding values. update corresponds to replacing that conceptual `Map' with a new one. of course, the implementation actually uses update-in-place to perform this, since it knows it's passed the unique reference to `State# RealWorld')
2021-02-22 03:34:42 +0100 <edwardk> and there's a couple of rules in the compiler that keep operations from floating out past the token
2021-02-22 03:34:51 +0100 <anselmschueler> so why is it State# RealWorld instead of RealWorld
2021-02-22 03:35:05 +0100 <edwardk> because ST s is the same thing generalized a tiny bit
2021-02-22 03:35:21 +0100 <edwardk> newtype ST s = ST { unST :: State# s -> (# State# s, a #) }
2021-02-22 03:35:23 +0100 <edwardk> and er
2021-02-22 03:35:27 +0100 <edwardk> newtype ST s a = ST { unST :: State# s -> (# State# s, a #) }
2021-02-22 03:35:30 +0100Lord_of_Life_(~Lord@unaffiliated/lord-of-life/x-0885362)
2021-02-22 03:35:32 +0100 <anselmschueler> ski but wouldn't a comprehensive IO monad need to include OS system calls and the like
2021-02-22 03:35:40 +0100 <ski> anselmschueler : yes, sure
2021-02-22 03:35:46 +0100 <edwardk> and we want 's' there to have kind Type
2021-02-22 03:35:48 +0100 <edwardk> but if that was
2021-02-22 03:35:51 +0100 <ski> we're only talking about the local mutable memory aspect, here
2021-02-22 03:35:57 +0100 <anselmschueler> ok
2021-02-22 03:35:57 +0100Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362) (Ping timeout: 264 seconds)
2021-02-22 03:36:00 +0100 <ski> (local to the process)
2021-02-22 03:36:01 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 03:36:07 +0100 <edwardk> newtype ST s a = ST { unST :: s -> (# s, a #) } -- then that Type would be a real heap object doing nothing and we reinvented the state monad
2021-02-22 03:36:16 +0100 <edwardk> i want to pass a 0-byte 'tag' around, not a real object.
2021-02-22 03:36:29 +0100stree(~stree@68.36.8.116)
2021-02-22 03:36:30 +0100 <anselmschueler> ok
2021-02-22 03:36:40 +0100 <edwardk> now internally haskell can FFI out to C or whatever, or maybe do mutable operations and those operations are tagged by passing around State# tokens
2021-02-22 03:36:54 +0100Lord_of_Life_Lord_of_Life
2021-02-22 03:37:10 +0100 <edwardk> e.g. IORef exists and is a pointer-like thing
2021-02-22 03:37:12 +0100 <edwardk> internally
2021-02-22 03:37:16 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:7ce7:fe06:1dad:4fcd) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 03:37:33 +0100 <edwardk> data IORef a = IORef (MutVar# RealWorld a)
2021-02-22 03:37:39 +0100 <anselmschueler> sorry for going off-topic, but I'm intrigued by that leave message by polyraid — how do you customize the leave message
2021-02-22 03:37:39 +0100 <edwardk> and to make one internally we have
2021-02-22 03:37:51 +0100 <anselmschueler> sorry
2021-02-22 03:37:56 +0100 <edwardk> newMutVar# :: a -> State# d -> (# State# d, MutVar# d a #)
2021-02-22 03:38:09 +0100 <edwardk> readMutVar# :: MutVar# d a -> State# d -> (# State# d, a #)
2021-02-22 03:38:15 +0100 <ski> edwardk : would `type Lev a = (# #) -> a' work, btw ?
2021-02-22 03:38:18 +0100 <edwardk> writeMutVar# :: MutVar# d a -> a -> State# d -> State# d
2021-02-22 03:38:28 +0100 <edwardk> ski: the user would see the -> then
2021-02-22 03:38:34 +0100 <ski> yes
2021-02-22 03:38:46 +0100 <ski> but apart from that inconvenience ?
2021-02-22 03:38:48 +0100 <edwardk> with (()~()) => i have some hope the compiler can erase that to 0-width ~#'s
2021-02-22 03:38:57 +0100pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net) (Ping timeout: 264 seconds)
2021-02-22 03:39:06 +0100 <edwardk> yes
2021-02-22 03:39:15 +0100 <anselmschueler> ok I think I understand — it's because the compiler is doing impure stuff under the hood
2021-02-22 03:39:22 +0100 <edwardk> and i STILL want CONSTRAINT r for r :: RuntimeRep ;)
2021-02-22 03:39:48 +0100 <edwardk> anselmschueler: we package this up in away that 99% of the users never see this secret State# passing stuff
2021-02-22 03:39:50 +0100 <anselmschueler> so by the time something gets evaluated, the mutable array from which the array was created may have been changed, which is what the linear types want to prevent
2021-02-22 03:40:13 +0100 <anselmschueler> correct?
2021-02-22 03:40:24 +0100 <edwardk> runST :: (forall s. ST s a) -> a -- is another 'safe' way to manufacture and temporarily use a State# token.
2021-02-22 03:40:36 +0100 <edwardk> it feeds a fresh one in the the ST s computation, runs and disposes of it
2021-02-22 03:40:58 +0100 <edwardk> and all the STArray stuff is tagged with that token and doesn't give you operations for dereferencing it without access to that token
2021-02-22 03:41:03 +0100 <edwardk> so its safe to use in pure code
2021-02-22 03:41:13 +0100 <ski> anselmschueler : anyway, i stress thinking of a value of type `IOArray i e'/`STArray s i e' or `IORef a'/`STRef s a' as an index, to emphasize that, conceptually, this value does *not* contain the value in the mutable box (anymore than an `Int' index into `[a]' or `IntMap a' or `Map Int a' contains the `a' value). this also explains why we have `Eq (IORef a)', not requiring `Eq a'. it's conceptually
2021-02-22 03:41:19 +0100 <ski> "comparing indices"
2021-02-22 03:41:27 +0100guest222(~user@49.5.6.87)
2021-02-22 03:41:28 +0100 <edwardk> the goal of linear types here is to provide a third way to guarantee its okay to use the array.
2021-02-22 03:41:37 +0100 <zzz> fgl is great.
2021-02-22 03:41:39 +0100skinods to edwardk
2021-02-22 03:42:15 +0100chibi(~chibi@75-26-238-119.lightspeed.glvwil.sbcglobal.net)
2021-02-22 03:42:19 +0100 <chibi> yello
2021-02-22 03:42:23 +0100 <anselmschueler> and the reason the array might not be ok is that it's not a pure value and by the time something gets *evaluated* using the immutable array based on it it might've been modified?
2021-02-22 03:42:23 +0100star_cloud(~star_clou@ec2-34-220-44-120.us-west-2.compute.amazonaws.com)
2021-02-22 03:42:45 +0100 <edwardk> which is that you can know that you have the only reference to the array, and so you can think of that as bundling the array and the State# you are supposed to thread through your program. internally, morally the State# s is a 'linear' object. it shouldn't be able to be copied. (unsafeInterleaveIO being a notable unsafe operation that does so)
2021-02-22 03:43:01 +0100 <ski> anselmschueler : for `runST', conceptually, `State# s' will be a tuple or record containing all the cells that we will allocate with `newSTRef' & `newSTArray', in that state thread
2021-02-22 03:43:05 +0100 <chibi> When is it better to use Reader r a instead of just having a function r -> a?
2021-02-22 03:43:10 +0100 <edwardk> so linear-base is relying on the same sort of safety condition that we usually get by packing up the State# in the monad
2021-02-22 03:43:31 +0100 <anselmschueler> zzz: what's fgl
2021-02-22 03:43:52 +0100 <edwardk> chibi: when you might switch to ReaderT later? maybe. really no reason otherwise.
2021-02-22 03:43:56 +0100 <ski> chibi : when you want to slap some other monad transformer on top of `Reader r' ?
2021-02-22 03:44:07 +0100 <edwardk> chibi: oh and you want to force your user to think about that argument as special and use 'ask' to access it rather than just take another arg.
2021-02-22 03:44:21 +0100 <chibi> Hm...I understand how monad transformers work, but I never seem to know when to use them.
2021-02-22 03:44:26 +0100 <edwardk> zzz: martin erwig's functional graph library, they asked for a suggestion about graphs earlier.
2021-02-22 03:44:36 +0100 <chibi> Like, what are the advantages of using a monad stack in general?
2021-02-22 03:44:42 +0100 <anselmschueler> ok so is the following correct: "the reason the array might not be ok is that it's not a pure value and by the time something gets *evaluated* using the immutable array based on it it might've been modified"
2021-02-22 03:44:47 +0100 <anselmschueler> ?
2021-02-22 03:45:06 +0100 <dolio> Sometimes it's nice to not have to thread the argument through a bunch of functions.
2021-02-22 03:45:30 +0100 <edwardk> chibi: i wrote a large application, now i want to thread a tiny piece of additional state through the application. do i rewrite _every function signature_ even the ones that don't use that bit of state? or do i write the functions parameterized on what they need?
2021-02-22 03:45:38 +0100 <edwardk> instead of locking in an exact signature i can work with
2021-02-22 03:45:45 +0100carlomagno(~cararell@148.87.23.9)
2021-02-22 03:46:01 +0100 <edwardk> foo :: (MonadState s m, MonadReader e m) => m MyResult
2021-02-22 03:46:18 +0100 <edwardk> and if some other bit of code needs an exception handling it picks up the constraint and adds it to the bag of things on the left of the =>
2021-02-22 03:46:29 +0100 <ski> anselmschueler : i think you should try to separate the conceptual semantics of it, from the "accidental" optimization of implementing it by "update-in-place"
2021-02-22 03:46:36 +0100 <edwardk> when you're done you dispatch that stuff by peeling off monad transformers
2021-02-22 03:47:01 +0100 <chibi> So you just change your monad stack synonymn type instead of the individual signatures or?
2021-02-22 03:47:06 +0100aarvar(~foewfoiew@2601:602:a080:fa0:394a:95d6:26a0:dc43)
2021-02-22 03:47:13 +0100mehwork(~mehwork@98.185.199.35.bc.googleusercontent.com)
2021-02-22 03:47:38 +0100 <anselmschueler> ski I don't understand
2021-02-22 03:47:39 +0100viluon(uid453725@gateway/web/irccloud.com/x-vfqtytiryjprhruz) (Quit: Connection closed for inactivity)
2021-02-22 03:47:40 +0100 <edwardk> anselmschueler: in the backend GHC has MutableArray# s a and Array# a -- Array# is designed so you can access it purely. indexing operations can be used by normal code. MutableArray# is designed so that folks can read or write to the array.
2021-02-22 03:47:53 +0100 <ski> anselmschueler : conceptually, you have different versions of state values, that're threaded along the computation, under the covers, just as with regular `State'
2021-02-22 03:48:04 +0100 <edwardk> anselmschueler: when you are done with the mutable use of the array you 'freeze' it and produce an array# which can be used from pure code
2021-02-22 03:48:13 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:15cd:c67f:11dd:b9fc)
2021-02-22 03:48:29 +0100justsomeguy(~justsomeg@unaffiliated/--/x-3805311) (Quit: WeeChat 3.0)
2021-02-22 03:48:40 +0100 <edwardk> a typical array construction procedure is to use the ST s monad to build an STArray s a freeze that to get an Array a and it looks like pure code build a big flat slab of memory with stuff in it
2021-02-22 03:48:43 +0100 <anselmschueler> ok - and MutableArray# is not a pure Haskell value, right?
2021-02-22 03:48:50 +0100wei2912(~wei2912@unaffiliated/wei2912)
2021-02-22 03:48:56 +0100oisdk(~oisdk@2001:bb6:3329:d100:c73:1525:4623:7479) (Quit: oisdk)
2021-02-22 03:49:38 +0100 <Axman6> I'm not sure how one would answer that
2021-02-22 03:49:52 +0100xcmw(~textual@dyn-72-33-2-47.uwnet.wisc.edu) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 03:49:56 +0100 <edwardk> a MutableArray# has well defined operations on it but its implemented by the runtime system. if you stick to the operations in GHC.Prim and never duplicate a State# s (and don't access out of bounds) then everything you can do with a MutableArray# is safe, even if internally its implemented by scribbling into a slab of memory
2021-02-22 03:49:58 +0100 <ski> anselmschueler : now, what `ST' (and corresponding `IO' operations) gives you, apart from what you could implement with that in Haskell (disregarding efficiency) is being able to have both (a) dynamic allocation of new pieces of state; and (b) allow the types of the pieces of states to be arbitrary (not all necessarily the same)
2021-02-22 03:50:03 +0100nhs(~nhs@c-67-180-177-103.hsd1.ca.comcast.net)
2021-02-22 03:50:24 +0100 <anselmschueler> I think I understand sorta
2021-02-22 03:50:44 +0100 <minoru_shiraeesh> in haskell you can create islands of purity in impure sea, and you can create islands of impurity in a sea of purity
2021-02-22 03:50:45 +0100 <edwardk> but the fundamental 'workflow' around it is that of imperatively banging values into it.
2021-02-22 03:51:00 +0100 <edwardk> just like IORef is mutable, but the mutation is guarded by State# s passing.
2021-02-22 03:51:19 +0100redcherri(bab702c9@186.183.2.201)
2021-02-22 03:51:38 +0100 <edwardk> linear types just give us another way to pass that State# safety guarantee along than hiding it in a monad away from prying eyes
2021-02-22 03:52:01 +0100 <ski> anselmschueler : you could easily implement `newStringRef :: String -> StringState StringRef' where `StringState = State [String]' and `StringRef = Int', and then also `readStringRef :: StringRef -> StringState String',`writeStringRef :: StringRef -> String -> StringState ()'
2021-02-22 03:52:17 +0100 <edwardk> as a general rule of thumb you can use a monad to sneak around _one_ linear resource by hiding it from outside eyes. in haskell we choose that one resource to be State# s in IO and ST s.
2021-02-22 03:52:37 +0100pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net)
2021-02-22 03:52:38 +0100 <anselmschueler> ok
2021-02-22 03:52:45 +0100 <edwardk> basically it morally is passing the heap around and state of user interaction (its not quite exactly that when you get multiple threads involved, but it is the moral equivalent)
2021-02-22 03:52:47 +0100 <Axman6> minoru_shiraeesh: and with ST, you can sometimes prove those islands of impurity are referentially transparant and therefore actually pure, even if internally they are implemented with mutation
2021-02-22 03:53:07 +0100 <zzz> i wish there was lazy Natural type already, that would collapse it's value into a binary unsigned "behind the scenes" int whenever it was needed but kept it's Succ(Succ(...Zero) purely functional nature
2021-02-22 03:53:28 +0100 <edwardk> linear haskell lets you start passing around more than one linear resource at a time in a more fine-grained fashion than the monad-for-managing-a-single-linear-resource pattern can offer.
2021-02-22 03:53:58 +0100 <guest222> what an action would do in a do-notaion? x :: Maybe Int = do { Just 3; y <- Just 5 } what this Just 3 is doing here?
2021-02-22 03:54:02 +0100 <ski> anselmschueler : but you want to be able to have references to boxes containing values of arbitrary types, selected by the user in each case. afaik, that can't be implemented in Haskell itself (i guess one may be able to do it, with a `Typeable' constraint, but without that, i dunno how it could work)
2021-02-22 03:54:16 +0100nhs(~nhs@c-67-180-177-103.hsd1.ca.comcast.net) (Ping timeout: 240 seconds)
2021-02-22 03:54:48 +0100 <ski> anselmschueler : the second thing that `ST' gives here, is the update-in-place "optimization", which is warranted by the state versions being threaded around being unique
2021-02-22 03:54:53 +0100 <edwardk> ST gives us an escape hatch to locally use mutation to make things with references/arrays in otherwise pure code. manufacturing a fresh State# then throwing it away when its done so that you don't need to worry about folks mutating anything outside of a single linear control flow path that is done and frozen when you come out of runST.
2021-02-22 03:55:16 +0100 <ski> (note that linear is not the same as unique, though)
2021-02-22 03:55:19 +0100 <edwardk> IO doesn't have to 'end' because the State# token is 'god given' to you at the start of main and you just pass it around your program.
2021-02-22 03:55:22 +0100hexfive(~hexfive@50.35.83.177) (Ping timeout: 260 seconds)
2021-02-22 03:55:24 +0100 <Axman6> zzz: why not data Nat = Zero | One | ZeroBit Nat | OneBit) Nat? I just saved you so much memory!
2021-02-22 03:55:30 +0100 <edwardk> (ignoring unsafePerformIO shenanigans)
2021-02-22 03:55:40 +0100ski. o O ( `Start :: *World -> *World' )
2021-02-22 03:55:53 +0100 <Axman6> s/)//
2021-02-22 03:56:35 +0100 <edwardk> Axman6: now you need to quotient by OneBit One = One and ZeroBit Zero = Zero
2021-02-22 03:56:35 +0100drbean(~drbean@TC210-63-209-191.static.apol.com.tw)
2021-02-22 03:56:39 +0100 <ski> guest222 : do you know how `do'-notation is desugared into `>>=' and `>>' ?
2021-02-22 03:56:42 +0100 <Axman6> guest222: it's not really doing anything, but if it were instead Nothing, then the result would be Nothing
2021-02-22 03:56:43 +0100 <guest222> main = do { print "1"; print "2" }
2021-02-22 03:56:54 +0100 <guest222> ski: yes
2021-02-22 03:57:06 +0100 <ski> guest222 : then go look up how those two work, for `Maybe' ?
2021-02-22 03:57:10 +0100 <edwardk> Axman6: either by using pattern synonyms or making a more complicated data type to maintain the invariants
2021-02-22 03:57:15 +0100 <Axman6> try desugaring that expression and the evaluating it
2021-02-22 03:57:24 +0100 <ski> @src Maybe (>>=)
2021-02-22 03:57:24 +0100 <lambdabot> (Just x) >>= k = k x
2021-02-22 03:57:24 +0100 <lambdabot> Nothing >>= _ = Nothing
2021-02-22 03:57:35 +0100 <anselmschueler> goodbye
2021-02-22 03:57:37 +0100anselmschueler(2e72278d@dynamic-046-114-039-141.46.114.pool.telefonica.de) (Quit: Connection closed)
2021-02-22 03:58:03 +0100 <Axman6> OneBit One would just be 3, but you're right, ZeroBit Zero is lame
2021-02-22 03:58:25 +0100 <edwardk> Axman6: i assumed One was an infinite tail of ones
2021-02-22 03:58:39 +0100 <edwardk> that gives you infinite precision 2s complement arithmetic
2021-02-22 03:58:44 +0100 <Axman6> data Nat = Null | ZeroBit Nat | OneBit Nat -- fixed!
2021-02-22 03:59:17 +0100 <edwardk> 0 = Null = ZerBit Null
2021-02-22 03:59:34 +0100 <edwardk> use zeroless binary
2021-02-22 03:59:52 +0100 <edwardk> data Nat = Zero | One Nat | Two Nat
2021-02-22 04:00:13 +0100 <edwardk> where digits are still worth 2 * the previous digit and your binary numbers have 1s and 2s in each place and an infinite tail of 0s
2021-02-22 04:00:13 +0100 <Axman6> nal, Null = NaN >_>
2021-02-22 04:00:15 +0100 <edwardk> THAT is fixed
2021-02-22 04:00:25 +0100ski. o O ( <https://lambdacats.github.io/fixed-in-head.jpg> )
2021-02-22 04:00:56 +0100 <edwardk> Axman6: the above is a well defined number scheme
2021-02-22 04:00:59 +0100 <Axman6> edwardk: I seem to remember this being an important part of your talk on cache oblivious maps at LJ many years ago
2021-02-22 04:01:21 +0100 <edwardk> cache oblivious maps used 2s and 3s, and 1 only as the most significant non-0
2021-02-22 04:01:32 +0100 <edwardk> and the same infinite tail of 0s
2021-02-22 04:01:51 +0100 <edwardk> also unique but folks tend not to think of binary as numbers made out of 2s and 3s for some reason. crazy i know.
2021-02-22 04:02:01 +0100 <edwardk> 0,1,2,3 -- is clearly binary
2021-02-22 04:02:03 +0100 <Axman6> yeah, crazy
2021-02-22 04:02:16 +0100toorevitimirp(~tooreviti@117.182.181.253)
2021-02-22 04:02:16 +0100gentauro(~gentauro@unaffiliated/gentauro) (Read error: Connection reset by peer)
2021-02-22 04:02:24 +0100Stanley00(~stanley00@unaffiliated/stanley00)
2021-02-22 04:02:39 +0100 <edwardk> 0,1,2,3,12,13,22,23,32,33...
2021-02-22 04:02:54 +0100 <edwardk> every number is uniquely represented under those constraints
2021-02-22 04:03:10 +0100gentauro(~gentauro@unaffiliated/gentauro)
2021-02-22 04:03:16 +0100 <edwardk> *natural
2021-02-22 04:03:19 +0100 <Axman6> does addition look weird?
2021-02-22 04:03:29 +0100 <edwardk> don't need addition. need cheap 'succ'
2021-02-22 04:03:42 +0100 <edwardk> addition is left as an exercise for the reader.
2021-02-22 04:04:01 +0100 <Axman6> just curious if adding them is particularly difficult, I'm buessing probably not that hard
2021-02-22 04:04:08 +0100 <Axman6> guessing*
2021-02-22 04:04:09 +0100 <edwardk> compared to skew binary its easy
2021-02-22 04:04:45 +0100 <edwardk> and yeah its easy, you just have larger ranges of carry options
2021-02-22 04:05:36 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 240 seconds)
2021-02-22 04:05:55 +0100 <edwardk> 3+3 can overflow what can be represented in a digit by up to 3 in a half-adder, and in a full adder you now have a slightly wider range still
2021-02-22 04:06:15 +0100 <edwardk> compared to carry being 0 or 1 in normal binary
2021-02-22 04:06:56 +0100 <guest222> what this return doing in "C.runContT (sequence_ contArr) return" https://paste.ubuntu.com/p/YzBvBhbfJM/
2021-02-22 04:07:14 +0100 <Axman6> it's the continuation that is being passed in
2021-02-22 04:07:17 +0100 <Axman6> :t runCont
2021-02-22 04:07:18 +0100 <lambdabot> Cont r a -> (a -> r) -> r
2021-02-22 04:07:27 +0100 <ski> guest222 : `evalContT act = runContT act return'
2021-02-22 04:07:27 +0100 <edwardk> :t runContT
2021-02-22 04:07:28 +0100 <lambdabot> forall k (r :: k) (m :: k -> *) a. ContT r m a -> (a -> m r) -> m r
2021-02-22 04:07:37 +0100 <ski> @let evalContT act = runContT act return
2021-02-22 04:07:38 +0100 <lambdabot> .L.hs:184:1: error:
2021-02-22 04:07:38 +0100 <lambdabot> Multiple declarations of ‘evalContT’
2021-02-22 04:07:38 +0100 <lambdabot> Declared at: .L.hs:182:1
2021-02-22 04:07:38 +0100 <Axman6> it's the a -> r, with type a -> m a
2021-02-22 04:07:44 +0100 <ski> @type evalContT
2021-02-22 04:07:45 +0100 <lambdabot> Applicative i => ContT o i o -> i o
2021-02-22 04:07:53 +0100 <ski> oh, it was lingering
2021-02-22 04:08:01 +0100 <Axman6> (sorry, missed the T, but it's essentially the same thing)
2021-02-22 04:08:06 +0100gzj(~gzj@unaffiliated/gzj) (Remote host closed the connection)
2021-02-22 04:08:12 +0100 <ski> (similarly, `evalCont act = runCont act id')
2021-02-22 04:08:26 +0100gzj(~gzj@unaffiliated/gzj)
2021-02-22 04:08:30 +0100urodna(~urodna@unaffiliated/urodna) (Quit: urodna)
2021-02-22 04:09:05 +0100nullniv40(~null@unaffiliated/nullniverse)
2021-02-22 04:09:28 +0100 <ski> guest222 : the most common continuation you want to provide, when running an action in `Cont o'/`ContT o m', is the trivial one, being `id' alt. `pure'/`return'
2021-02-22 04:09:38 +0100 <guest222> runCont (cont $ \k -> k 3) id == 3, this I understand, runCont (cont $ \k -> k 3) would extract \k -> k 3 from it, but what "return " ?
2021-02-22 04:10:03 +0100 <ski> `return' is for the `ContT' version
2021-02-22 04:10:25 +0100 <guest222> ski oh, like "id" in Cont?
2021-02-22 04:10:27 +0100 <Axman6> you just end up with "return 3", as before you had "id 3"
2021-02-22 04:10:30 +0100 <ski> guest222 : yes
2021-02-22 04:11:02 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net) (Remote host closed the connection)
2021-02-22 04:12:10 +0100nullniverse(~null@unaffiliated/nullniverse) (Ping timeout: 260 seconds)
2021-02-22 04:15:23 +0100 <zzz> edwardk: Axman6: i'm interested. any chance of a link to the lambdajam talk?
2021-02-22 04:16:21 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de) (Ping timeout: 246 seconds)
2021-02-22 04:16:49 +0100 <Axman6> I think it was https://www.youtube.com/watch?v=WE2a90Bov0Q
2021-02-22 04:17:44 +0100xcmw(~textual@dyn-72-33-2-47.uwnet.wisc.edu)
2021-02-22 04:19:05 +0100 <zzz> awesome thanks
2021-02-22 04:19:37 +0100 <chibi> Crap, GHC almost crashed my computer. Is it normal for cabal-install to impart a massive amount of load while compiling packages?
2021-02-22 04:20:08 +0100 <yushyin> yup
2021-02-22 04:20:22 +0100 <Axman6> Man, I don't understand people. "Look how hard it is to understand monads in Haskell" "Look at this implementation of monadic flat_map in Rust" *proceeds to spew crazy amounts of opaque code*. https://www.eltonpinto.me/blog/posts/implementing_flatmap_in_rust/
2021-02-22 04:20:39 +0100 <yushyin> also lots of RAM usage
2021-02-22 04:20:43 +0100 <Axman6> chibi: compilers gonna compile
2021-02-22 04:21:58 +0100nhs(~nhs@c-67-180-177-103.hsd1.ca.comcast.net)
2021-02-22 04:22:54 +0100FinnElija(~finn_elij@gateway/tor-sasl/finnelija/x-67402716)
2021-02-22 04:22:54 +0100finn_elijaGuest72233
2021-02-22 04:22:54 +0100FinnElijafinn_elija
2021-02-22 04:23:42 +0100 <chibi> Ha yeah, but it'd rather it take a little longer in exchange for not choking my computer to the point of being unable to kill it while compiling--is there a way to limit the CPU/RAM usage rate on GHC?
2021-02-22 04:24:04 +0100 <Axman6> you can probably tell it not to compile things in parallel
2021-02-22 04:24:57 +0100 <falsifian> chibi: If you'd prefer ghc to die before it can get to that point and you're using something unix-like, you could look into the ulimit command.
2021-02-22 04:25:13 +0100hongminhee(~dahlia@207.148.91.209)
2021-02-22 04:25:35 +0100 <yushyin> cgroups can help you with that, if you are on linux
2021-02-22 04:25:56 +0100nhs(~nhs@c-67-180-177-103.hsd1.ca.comcast.net) (Ping timeout: 240 seconds)
2021-02-22 04:26:08 +0100poscat(~poscat@2408:8207:4825:b3e0::1)
2021-02-22 04:26:15 +0100Guest72233(~finn_elij@gateway/tor-sasl/finnelija/x-67402716) (Ping timeout: 268 seconds)
2021-02-22 04:26:25 +0100 <chibi> I'll look into those, thanks
2021-02-22 04:26:43 +0100plutoniix(~q@ppp-124-121-236-209.revip2.asianet.co.th)
2021-02-22 04:26:56 +0100redcherri(bab702c9@186.183.2.201) ()
2021-02-22 04:27:53 +0100 <yushyin> you can limit cpu shares and memory usage, pretty nifty
2021-02-22 04:28:02 +0100 <Axman6> you can use -j 1 to make it one only a single CPU
2021-02-22 04:28:15 +0100 <Axman6> https://cabal.readthedocs.io/en/3.4/cabal-project.html?highlight=parallel#cfg-field-jobs
2021-02-22 04:28:26 +0100aarvar(~foewfoiew@2601:602:a080:fa0:394a:95d6:26a0:dc43) (Ping timeout: 240 seconds)
2021-02-22 04:31:45 +0100 <guest222> x == 3 is ok, what about x == id?
2021-02-22 04:32:16 +0100 <Axman6> I don't understand the question
2021-02-22 04:32:38 +0100 <guest222> x = 3; x == 3 return a Bool, right?
2021-02-22 04:32:50 +0100 <guest222> x = id; x == id?
2021-02-22 04:33:17 +0100 <zzz> guest222 id is a function and functions are opaque. you cant test for equality
2021-02-22 04:33:30 +0100 <guest222> zzz: ok
2021-02-22 04:35:03 +0100nhs(~nhs@c-67-180-177-103.hsd1.ca.comcast.net)
2021-02-22 04:37:04 +0100 <zzz> guest222: deciding if 2 functions are equal without testing all possible inputs is solving the halting problem
2021-02-22 04:37:33 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 04:37:46 +0100 <ski> @where impossible
2021-02-22 04:37:46 +0100 <lambdabot> <http://math.andrej.com/2007/09/28/seemingly-impossible-functional-programs/>,<http://math.andrej.com/2008/11/21/a-haskell-monad-for-infinite-search-in-finite-time/>
2021-02-22 04:38:33 +0100 <ski> @quote things.are.possible
2021-02-22 04:38:33 +0100 <lambdabot> autrijus says: Perl: "Easy things are easy, hard things are possible" <autrijus> Haskell: "Hard things are easy, the impossible just happened"
2021-02-22 04:39:38 +0100nhs(~nhs@c-67-180-177-103.hsd1.ca.comcast.net) (Ping timeout: 256 seconds)
2021-02-22 04:39:43 +0100alx741(~alx741@186.178.109.47) (Quit: alx741)
2021-02-22 04:42:08 +0100 <zzz> oh man, I was just about to go sleep
2021-02-22 04:42:10 +0100 <zzz> oh well
2021-02-22 04:42:38 +0100lambda-11235(~lambda-11@2600:1700:7c70:4600:305f:2287:bde6:feb9)
2021-02-22 04:43:49 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net)
2021-02-22 04:44:10 +0100Tario(~Tario@201.192.165.173) (Ping timeout: 256 seconds)
2021-02-22 04:45:38 +0100 <guest222> so not all the values can be compared?
2021-02-22 04:48:33 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net) (Ping timeout: 264 seconds)
2021-02-22 04:49:29 +0100hexfive(~hexfive@50.35.83.177)
2021-02-22 04:50:07 +0100mp___(mp@hell.cx) (Remote host closed the connection)
2021-02-22 04:50:09 +0100juri_(~juri@178.63.35.222)
2021-02-22 04:50:34 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 04:50:43 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 04:53:55 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:15cd:c67f:11dd:b9fc) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 04:54:33 +0100theDon(~td@94.134.91.187) (Ping timeout: 264 seconds)
2021-02-22 04:55:42 +0100ddellacosta(~ddellacos@86.106.143.111) (Remote host closed the connection)
2021-02-22 04:55:57 +0100theDon(~td@94.134.91.35)
2021-02-22 04:56:03 +0100 <zzz> in Haskell, you get the (==) operator from the Eq class
2021-02-22 04:56:28 +0100 <zzz> so only types that have Eq instances are comparable
2021-02-22 04:56:41 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec)
2021-02-22 05:00:05 +0100 <zzz> @type (==)
2021-02-22 05:00:06 +0100 <lambdabot> Eq a => a -> a -> Bool
2021-02-22 05:00:56 +0100darjeeling_(~darjeelin@122.245.217.214) (Ping timeout: 240 seconds)
2021-02-22 05:02:21 +0100mp___(mp@hell.cx)
2021-02-22 05:03:37 +0100 <guest222> a ~ (b->b)
2021-02-22 05:03:45 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net) (Ping timeout: 272 seconds)
2021-02-22 05:04:28 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 05:07:58 +0100nullniv40(~null@unaffiliated/nullniverse) (Remote host closed the connection)
2021-02-22 05:08:09 +0100 <zzz> (Eq a =>) is a contraint,it means that a has to belong to the Eq class
2021-02-22 05:08:11 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 268 seconds)
2021-02-22 05:08:35 +0100 <zzz> ((->) a b) , or (a -> b) does not
2021-02-22 05:10:52 +0100 <chibi> What *is* the ((->) a) data type?
2021-02-22 05:11:11 +0100 <chibi> I've seen it mentioned in relation to pointfree code but I don't understand it at all
2021-02-22 05:11:12 +0100 <c_wraith> the type of functions from a to missing
2021-02-22 05:11:16 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-22 05:11:25 +0100 <c_wraith> Like.. You know how Either a still has a missing type variable?
2021-02-22 05:11:37 +0100 <c_wraith> ((->) a) is functions with a missing argument
2021-02-22 05:14:43 +0100 <chibi> Yo...wait.
2021-02-22 05:14:51 +0100chibi's brain has undergone meltdown
2021-02-22 05:15:02 +0100 <c_wraith> So, (->) is usually infix
2021-02-22 05:15:06 +0100 <c_wraith> like a -> b
2021-02-22 05:15:10 +0100 <zzz> yes
2021-02-22 05:15:23 +0100 <zzz> but it's really (->) a b
2021-02-22 05:15:26 +0100 <c_wraith> but you can also write it in parens, prefix, like any other operator. Like ((->) a b)
2021-02-22 05:15:39 +0100 <chibi> And you can have it missing too?
2021-02-22 05:15:46 +0100 <zzz> yes
2021-02-22 05:15:56 +0100 <c_wraith> Sure. You can't have values of an incomplete type
2021-02-22 05:16:02 +0100 <c_wraith> But you can talk about it.
2021-02-22 05:16:14 +0100dyeplexer(~lol@unaffiliated/terpin)
2021-02-22 05:16:30 +0100 <zzz> all functions are unary, and constructors are functions
2021-02-22 05:16:41 +0100 <zzz> (asterisk)
2021-02-22 05:16:44 +0100 <c_wraith> This is that whole "higher-kinded types" thing
2021-02-22 05:17:37 +0100darjeeling_(~darjeelin@122.245.217.214)
2021-02-22 05:18:19 +0100 <chibi> What kind does that give ((->) a)? * -> (* -> *) ?
2021-02-22 05:18:33 +0100 <c_wraith> yes
2021-02-22 05:18:37 +0100ep1ctetus(~epictetus@ip72-194-215-136.sb.sd.cox.net) (Read error: Connection reset by peer)
2021-02-22 05:18:50 +0100 <zzz> however beware, (->) is a special type in Haskell and while useful to think about it as just another type, the implementation disguises a white lie (as almost eveything in Haskell ;)
2021-02-22 05:19:30 +0100 <c_wraith> They moved all of the complexity regarding (->) into a mechanism that doesn't show up in kinds anymore.
2021-02-22 05:19:39 +0100 <c_wraith> That whole "levity polymorphism" thing
2021-02-22 05:20:04 +0100 <zzz> @kind (->)
2021-02-22 05:20:06 +0100 <lambdabot> * -> * -> *
2021-02-22 05:20:11 +0100 <zzz> @kind (->) Bool
2021-02-22 05:20:12 +0100 <lambdabot> * -> *
2021-02-22 05:20:44 +0100 <zzz> @kind (Bool -> Bool)
2021-02-22 05:20:45 +0100 <lambdabot> *
2021-02-22 05:22:04 +0100 <chibi> Ahah, knowing the kind signature makes it much more clearer. Man, currying kinds. Super weird. Thanks for the explanation, and I'll keep the implementation trickery in mind if I ever use it
2021-02-22 05:22:15 +0100 <chibi> I don't exactly plan to but hey, the more you know
2021-02-22 05:26:36 +0100bitmapper(uid464869@gateway/web/irccloud.com/x-ashwoxwvsstlgotp)
2021-02-22 05:30:43 +0100hexfive(~hexfive@50.35.83.177) (Read error: Connection reset by peer)
2021-02-22 05:31:08 +0100hexfive(~hexfive@50.35.83.177)
2021-02-22 05:35:41 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus)
2021-02-22 05:36:59 +0100ArsenArsen(~Arsen@fsf/member/ArsenArsen) (Quit: bye)
2021-02-22 05:40:40 +0100forgottenone(~forgotten@176.42.28.68)
2021-02-22 05:41:18 +0100darjeeling_(~darjeelin@122.245.217.214) (Ping timeout: 260 seconds)
2021-02-22 05:42:29 +0100Saukk(~Saukk@83-148-239-3.dynamic.lounea.fi)
2021-02-22 05:42:43 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 268 seconds)
2021-02-22 05:43:06 +0100jedws(~jedws@101.184.202.248) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 05:44:27 +0100darjeeling_(~darjeelin@122.245.217.214)
2021-02-22 05:44:34 +0100stree(~stree@68.36.8.116) (Ping timeout: 260 seconds)
2021-02-22 05:45:48 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus)
2021-02-22 05:45:57 +0100da39a3ee5e6b4b0d(~da39a3ee5@184.22.159.161) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 05:46:04 +0100jedws(~jedws@101.184.202.248)
2021-02-22 05:47:50 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Ping timeout: 260 seconds)
2021-02-22 05:50:40 +0100mirrorbird(~psutcliff@2a00:801:446:6dfc:fadb:e310:6ed2:16d) (Quit: Leaving)
2021-02-22 05:50:41 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 05:51:38 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 05:51:44 +0100 <edwardk> secretly there is a FUN :: Multiplicity -> TYPE r -> TYPE s -> Type and (->) = FUN 'Many and the next two arguments default to TYPE 'LiftedRep = Type for most uses.
2021-02-22 05:52:24 +0100 <edwardk> this allows -> to accept/return types of unlifted kinds as well as the usual lifted stuff you are used to
2021-02-22 05:53:26 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-02-22 05:57:20 +0100stree(~stree@68.36.8.116)
2021-02-22 05:59:46 +0100quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net) (Quit: ZNC 1.8.1 - https://znc.in)
2021-02-22 06:00:40 +0100minoru_shiraeesh(~shiraeesh@109.166.57.22) (Ping timeout: 265 seconds)
2021-02-22 06:04:19 +0100xcmw(~textual@dyn-72-33-2-47.uwnet.wisc.edu) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 06:06:35 +0100quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net)
2021-02-22 06:06:53 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta)
2021-02-22 06:11:04 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2021-02-22 06:12:15 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 272 seconds)
2021-02-22 06:13:34 +0100gioyik_(~gioyik@gateway/tor-sasl/gioyik)
2021-02-22 06:14:53 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:15cd:c67f:11dd:b9fc)
2021-02-22 06:15:08 +0100xcmw(~textual@dyn-72-33-2-47.uwnet.wisc.edu)
2021-02-22 06:16:01 +0100gioyik(~gioyik@gateway/tor-sasl/gioyik) (Ping timeout: 268 seconds)
2021-02-22 06:20:35 +0100forgottenone(~forgotten@176.42.28.68) (Remote host closed the connection)
2021-02-22 06:21:14 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec)
2021-02-22 06:23:36 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec) (Client Quit)
2021-02-22 06:27:17 +0100nhs(~nhs@c-67-180-177-103.hsd1.ca.comcast.net)
2021-02-22 06:27:58 +0100Wuzzy(~Wuzzy@p5b0df3df.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2021-02-22 06:31:47 +0100nhs(~nhs@c-67-180-177-103.hsd1.ca.comcast.net) (Ping timeout: 256 seconds)
2021-02-22 06:33:29 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:b8ec:9dfb:e531:1ee7:9134)
2021-02-22 06:33:46 +0100hendursaga(~weechat@gateway/tor-sasl/hendursaga) (Remote host closed the connection)
2021-02-22 06:36:39 +0100hendursaga(~weechat@gateway/tor-sasl/hendursaga)
2021-02-22 06:40:02 +0100mirrorbird(~psutcliff@2a00:801:446:6dfc:fadb:e310:6ed2:16d)
2021-02-22 06:43:32 +0100krkini(~kini@unaffiliated/kini)
2021-02-22 06:44:29 +0100rayyyy(~nanoz@gateway/tor-sasl/nanoz) (Quit: Leaving)
2021-02-22 06:44:43 +0100ddellacosta(~ddellacos@86.106.143.100)
2021-02-22 06:45:02 +0100kini(~kini@unaffiliated/kini) (Ping timeout: 264 seconds)
2021-02-22 06:46:10 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 06:46:34 +0100ddellaco_(ddellacost@gateway/vpn/mullvad/ddellacosta)
2021-02-22 06:46:57 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 06:49:26 +0100ddellacosta(~ddellacos@86.106.143.100) (Ping timeout: 260 seconds)
2021-02-22 06:50:33 +0100Saukk(~Saukk@83-148-239-3.dynamic.lounea.fi) (Remote host closed the connection)
2021-02-22 06:50:50 +0100fengh(~haskeller@ip72-205-40-121.dc.dc.cox.net) (Ping timeout: 260 seconds)
2021-02-22 06:50:56 +0100ddellaco_(ddellacost@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 240 seconds)
2021-02-22 06:54:20 +0100h2017(~h2017@bras-base-clbaon0201w-grc-32-142-114-145-140.dsl.bell.ca) (Quit: Leaving)
2021-02-22 06:55:04 +0100aplainzetakind(~johndoe@captainludd.powered.by.lunarbnc.net)
2021-02-22 06:59:42 +0100 <desophos> with quickcheck, is there a way to suppress the output of a particular `collect` but keep the rest of the output (e.g. # tests run, etc.)?
2021-02-22 06:59:48 +0100deviantfero(~deviantfe@190.150.27.58) (Ping timeout: 246 seconds)
2021-02-22 07:00:38 +0100jedws(~jedws@101.184.202.248) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 07:01:41 +0100 <desophos> i'm using `collect` in a hacky way, "labeling" each test case with its generated values to analyze later, so quickcheck spits out 100 labels after the test
2021-02-22 07:04:49 +0100idhugo(~idhugo@80-62-117-97-mobile.dk.customer.tdc.net)
2021-02-22 07:08:10 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 07:10:25 +0100kupi(uid212005@gateway/web/irccloud.com/x-mbplkmlzcjbllchc) (Quit: Connection closed for inactivity)
2021-02-22 07:12:11 +0100heatsink(~heatsink@2600:1700:bef1:5e10:2c3b:7c69:7266:b507) (Remote host closed the connection)
2021-02-22 07:15:06 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2021-02-22 07:15:42 +0100rekahsoft(~rekahsoft@cpe0008a20f982f-cm64777d666260.cpe.net.cable.rogers.com)
2021-02-22 07:15:50 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:15cd:c67f:11dd:b9fc) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 07:18:26 +0100krkini(~kini@unaffiliated/kini) (Ping timeout: 240 seconds)
2021-02-22 07:18:30 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 07:18:53 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:15cd:c67f:11dd:b9fc)
2021-02-22 07:19:50 +0100xff0x(~xff0x@2001:1a81:52fd:ec00:d491:9747:a76e:961a) (Ping timeout: 264 seconds)
2021-02-22 07:20:41 +0100xff0x(~xff0x@2001:1a81:52fd:ec00:6110:a16a:5169:e879)
2021-02-22 07:21:11 +0100 <Axman6> you might want to look at verboseCheck
2021-02-22 07:21:38 +0100kini(~kini@unaffiliated/kini)
2021-02-22 07:22:16 +0100rekahsoft(~rekahsoft@cpe0008a20f982f-cm64777d666260.cpe.net.cable.rogers.com) (Ping timeout: 240 seconds)
2021-02-22 07:23:29 +0100gzj(~gzj@unaffiliated/gzj) (Quit: Leaving)
2021-02-22 07:23:31 +0100 <Axman6> https://hackage.haskell.org/package/QuickCheck-2.14.2/docs/Test-QuickCheck.html#g:2
2021-02-22 07:23:39 +0100gzj(~gzj@unaffiliated/gzj)
2021-02-22 07:23:50 +0100 <Axman6> though, I guess that doesn't actually solve your problem
2021-02-22 07:24:30 +0100heatsink(~heatsink@2600:1700:bef1:5e10:2c3b:7c69:7266:b507)
2021-02-22 07:24:31 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta)
2021-02-22 07:28:57 +0100sz0(uid110435@gateway/web/irccloud.com/x-vgcbgmtbcanqkgvi)
2021-02-22 07:29:06 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 260 seconds)
2021-02-22 07:29:42 +0100jedws(~jedws@101.184.202.248)
2021-02-22 07:33:07 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2021-02-22 07:33:10 +0100cur8or(~cur8or@2c0f:fbe1:3:17:6d77:f5a5:800f:317)
2021-02-22 07:34:45 +0100ddellacosta(~ddellacos@83.143.246.103)
2021-02-22 07:37:33 +0100raym(~ray@45.64.220.3)
2021-02-22 07:38:00 +0100gienah(~mwright@gentoo/developer/gienah) (Quit: leaving)
2021-02-22 07:38:32 +0100gzj(~gzj@unaffiliated/gzj) (Quit: Leaving)
2021-02-22 07:38:54 +0100 <desophos> hmm, interesting. i might be able to use that instead of `collect` if i can redirect stdout
2021-02-22 07:38:55 +0100gzj(~gzj@unaffiliated/gzj)
2021-02-22 07:42:19 +0100pjb(~t@2a01cb04063ec500040d2a1d3a77e4c5.ipv6.abo.wanadoo.fr)
2021-02-22 07:42:38 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-02-22 07:44:25 +0100ddellacosta(~ddellacos@83.143.246.103) (Remote host closed the connection)
2021-02-22 07:46:07 +0100vglfr(~androirc@37.73.185.51)
2021-02-22 07:46:56 +0100danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa)
2021-02-22 07:47:31 +0100jedws(~jedws@101.184.202.248) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 07:51:05 +0100cheater(~user@unaffiliated/cheater) (Ping timeout: 240 seconds)
2021-02-22 07:51:33 +0100Varis(~Tadas@unaffiliated/varis)
2021-02-22 07:51:42 +0100jedws(~jedws@101.184.202.248)
2021-02-22 07:55:43 +0100vglfr(~androirc@37.73.185.51) (Read error: Connection reset by peer)
2021-02-22 07:55:55 +0100cheater(~user@unaffiliated/cheater)
2021-02-22 07:56:37 +0100vglfr(~androirc@37.73.185.51)
2021-02-22 07:57:15 +0100 <desophos> is there a way to do that in Haskell? as opposed to redirecting ghc stdout from bash
2021-02-22 07:57:29 +0100vglfr(~androirc@37.73.185.51) (Remote host closed the connection)
2021-02-22 07:58:24 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:15cd:c67f:11dd:b9fc) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 07:59:58 +0100average(uid473595@gateway/web/irccloud.com/x-jpwdoiumlhsnnhkn)
2021-02-22 08:02:24 +0100jedws(~jedws@101.184.202.248) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 08:03:33 +0100frozenErebus(~frozenEre@94.128.219.166)
2021-02-22 08:04:11 +0100xff0x(~xff0x@2001:1a81:52fd:ec00:6110:a16a:5169:e879) (Quit: xff0x)
2021-02-22 08:04:58 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2021-02-22 08:05:16 +0100stree(~stree@68.36.8.116) (Ping timeout: 240 seconds)
2021-02-22 08:07:14 +0100yangby(~secret@115.199.177.75)
2021-02-22 08:07:47 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:b8ec:9dfb:e531:1ee7:9134) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 08:09:28 +0100vicfred(vicfred@gateway/vpn/mullvad/vicfred) (Quit: Leaving)
2021-02-22 08:10:29 +0100Varis(~Tadas@unaffiliated/varis) (Remote host closed the connection)
2021-02-22 08:11:42 +0100vglfr(~auiee@37.73.185.51)
2021-02-22 08:12:25 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2021-02-22 08:13:40 +0100xff0x(~xff0x@2001:1a81:52fd:ec00:30b:4057:d2b:135)
2021-02-22 08:14:09 +0100 <desophos> it looks like `hDuplicateTo` in GHC.IO.Handle can do it
2021-02-22 08:16:44 +0100_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-02-22 08:17:24 +0100fengh(~haskeller@ip72-205-40-121.dc.dc.cox.net)
2021-02-22 08:18:28 +0100Sgeo(~Sgeo@ool-18b98aa4.dyn.optonline.net) (Read error: Connection reset by peer)
2021-02-22 08:18:57 +0100stree(~stree@68.36.8.116)
2021-02-22 08:19:04 +0100vglfr(~auiee@37.73.185.51) (Quit: leaving)
2021-02-22 08:20:25 +0100WarzoneCommand(~Frank@77-162-168-71.fixed.kpn.net) (Ping timeout: 240 seconds)
2021-02-22 08:21:20 +0100kini(~kini@unaffiliated/kini) (Quit: bye)
2021-02-22 08:22:39 +0100yangby(~secret@115.199.177.75) (Quit: Go out for a walk and buy a drink.)
2021-02-22 08:25:09 +0100kini(~kini@unaffiliated/kini)
2021-02-22 08:25:29 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:b8ec:9dfb:e531:1ee7:9134)
2021-02-22 08:29:13 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 268 seconds)
2021-02-22 08:29:57 +0100auiee(~auiee@37.73.185.51)
2021-02-22 08:30:48 +0100auieevglfr
2021-02-22 08:32:32 +0100carlomagno(~cararell@148.87.23.9) (Quit: Leaving.)
2021-02-22 08:32:39 +0100teardown(~user@gateway/tor-sasl/mrush) (Remote host closed the connection)
2021-02-22 08:33:00 +0100teardown(~user@gateway/tor-sasl/mrush)
2021-02-22 08:33:46 +0100vglfr(~auiee@37.73.185.51) (Client Quit)
2021-02-22 08:34:06 +0100vglfr(~vglfr@37.73.185.51)
2021-02-22 08:34:46 +0100raoul90(~raoulhida@nomnomnomnom.co.uk) (Quit: Ping timeout (120 seconds))
2021-02-22 08:34:58 +0100raoul90(~raoulhida@nomnomnomnom.co.uk)
2021-02-22 08:35:34 +0100vglfr(~vglfr@37.73.185.51) (Client Quit)
2021-02-22 08:35:52 +0100vglfr(~vglfr@37.73.185.51)
2021-02-22 08:36:29 +0100vglfr(~vglfr@37.73.185.51) (Client Quit)
2021-02-22 08:36:46 +0100vglfr(~vglfr@37.73.185.51)
2021-02-22 08:40:07 +0100gzj(~gzj@unaffiliated/gzj) (Remote host closed the connection)
2021-02-22 08:40:21 +0100vglfr(~vglfr@37.73.185.51) (Client Quit)
2021-02-22 08:40:28 +0100gzj(~gzj@unaffiliated/gzj)
2021-02-22 08:40:38 +0100vglfr(~vglfr@37.73.185.51)
2021-02-22 08:43:49 +0100frozenErebus(~frozenEre@94.128.219.166) (Ping timeout: 256 seconds)
2021-02-22 08:44:21 +0100idhugo_(~idhugo@80-62-117-86-mobile.dk.customer.tdc.net)
2021-02-22 08:44:40 +0100pavonia^\_^\(~user@unaffiliated/siracusa) (Quit: Bye!)
2021-02-22 08:44:57 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl)
2021-02-22 08:45:02 +0100kini(~kini@unaffiliated/kini) (Ping timeout: 264 seconds)
2021-02-22 08:45:15 +0100vglfr(~vglfr@37.73.185.51) (Client Quit)
2021-02-22 08:45:32 +0100vglfr(~vglfr@37.73.185.51)
2021-02-22 08:45:50 +0100kini(~kini@unaffiliated/kini)
2021-02-22 08:47:21 +0100idhugo(~idhugo@80-62-117-97-mobile.dk.customer.tdc.net) (Ping timeout: 264 seconds)
2021-02-22 08:48:55 +0100kini(~kini@unaffiliated/kini) (Excess Flood)
2021-02-22 08:51:00 +0100jedws(~jedws@101.184.202.248)
2021-02-22 08:51:58 +0100dhouthoo(~dhouthoo@ptr-eitgbj2w0uu6delkbrh.18120a2.ip6.access.telenet.be)
2021-02-22 08:52:56 +0100clog(~nef@bespin.org) (Ping timeout: 256 seconds)
2021-02-22 08:53:13 +0100kini(~kini@unaffiliated/kini)
2021-02-22 08:53:36 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 08:53:54 +0100minoru_shiraeesh(~shiraeesh@109.166.57.22)
2021-02-22 08:55:07 +0100vglfr(~vglfr@37.73.185.51) (Quit: leaving)
2021-02-22 08:56:10 +0100gioyik_(~gioyik@gateway/tor-sasl/gioyik) (Quit: WeeChat 3.0)
2021-02-22 08:58:25 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2021-02-22 08:59:15 +0100vglfr(~auiee@37.73.185.51)
2021-02-22 09:00:24 +0100ddellacosta(~ddellacos@86.106.143.72)
2021-02-22 09:02:28 +0100vglfr(~auiee@37.73.185.51) (Client Quit)
2021-02-22 09:03:25 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-22 09:03:47 +0100danso(~dan@2001:1970:52e7:d000:96b8:6dff:feb3:c009) (Ping timeout: 272 seconds)
2021-02-22 09:04:36 +0100ddellacosta(~ddellacos@86.106.143.72) (Ping timeout: 240 seconds)
2021-02-22 09:06:12 +0100bitmapper(uid464869@gateway/web/irccloud.com/x-ashwoxwvsstlgotp) (Quit: Connection closed for inactivity)
2021-02-22 09:06:19 +0100mirrorbird(~psutcliff@2a00:801:446:6dfc:fadb:e310:6ed2:16d) (Ping timeout: 272 seconds)
2021-02-22 09:06:23 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net)
2021-02-22 09:07:12 +0100bitmagie(~Thunderbi@200116b8066311005c3e5c1bf8f86d77.dip.versatel-1u1.de)
2021-02-22 09:08:01 +0100danso(~dan@2001:1970:52e7:d000:96b8:6dff:feb3:c009)
2021-02-22 09:08:47 +0100kuribas(~user@ptr-25vy0i9qfueg3sz2hh3.18120a2.ip6.access.telenet.be)
2021-02-22 09:11:04 +0100m0rphism1(~m0rphism@HSI-KBW-085-216-104-059.hsi.kabelbw.de)
2021-02-22 09:11:21 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net) (Ping timeout: 264 seconds)
2021-02-22 09:12:49 +0100rayyyy(~nanoz@gateway/tor-sasl/nanoz)
2021-02-22 09:13:45 +0100polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889) (Ping timeout: 258 seconds)
2021-02-22 09:13:49 +0100hiew(3dded63f@61-222-214-63.HINET-IP.hinet.net)
2021-02-22 09:13:56 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl) (Ping timeout: 240 seconds)
2021-02-22 09:15:51 +0100polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889)
2021-02-22 09:18:11 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl)
2021-02-22 09:18:55 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus)
2021-02-22 09:24:01 +0100heatsink(~heatsink@2600:1700:bef1:5e10:2c3b:7c69:7266:b507) (Remote host closed the connection)
2021-02-22 09:25:35 +0100frozenErebus(~frozenEre@94.128.219.166)
2021-02-22 09:26:11 +0100chele(~chele@ip5b40237d.dynamic.kabel-deutschland.de)
2021-02-22 09:27:06 +0100kini(~kini@unaffiliated/kini) (Remote host closed the connection)
2021-02-22 09:28:24 +0100kini(~kini@unaffiliated/kini)
2021-02-22 09:29:21 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2021-02-22 09:30:42 +0100Franciman(~francesco@host-82-49-79-189.retail.telecomitalia.it)
2021-02-22 09:31:16 +0100jedws(~jedws@101.184.202.248) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 09:31:16 +0100drbean(~drbean@TC210-63-209-191.static.apol.com.tw) (Ping timeout: 240 seconds)
2021-02-22 09:32:12 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2021-02-22 09:32:19 +0100kritzefitz(~kritzefit@fw-front.credativ.com)
2021-02-22 09:32:57 +0100frozenErebus(~frozenEre@94.128.219.166) (Ping timeout: 264 seconds)
2021-02-22 09:35:55 +0100Varis(~Tadas@unaffiliated/varis)
2021-02-22 09:37:12 +0100TMA(tma@twin.jikos.cz)
2021-02-22 09:38:41 +0100Yumasi(~guillaume@2a01:e0a:5cb:4430:46e1:3435:9ae8:d4e)
2021-02-22 09:38:47 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 09:40:47 +0100neiluj(~jco@91-167-203-101.subs.proxad.net)
2021-02-22 09:40:47 +0100neiluj(~jco@91-167-203-101.subs.proxad.net) (Changing host)
2021-02-22 09:40:47 +0100neiluj(~jco@unaffiliated/neiluj)
2021-02-22 09:44:08 +0100gzj(~gzj@unaffiliated/gzj) (Remote host closed the connection)
2021-02-22 09:44:23 +0100frozenErebus(~frozenEre@94.128.219.166)
2021-02-22 09:44:29 +0100gzj(~gzj@unaffiliated/gzj)
2021-02-22 09:46:30 +0100plutoniix(~q@ppp-124-121-236-209.revip2.asianet.co.th) (Read error: Connection reset by peer)
2021-02-22 09:46:48 +0100danza(~francesco@151.53.76.37)
2021-02-22 09:49:34 +0100frozenErebus(~frozenEre@94.128.219.166) (Ping timeout: 260 seconds)
2021-02-22 09:49:47 +0100borne(~fritjof@200116b864cae2007d6d461afdb4e2ff.dip.versatel-1u1.de)
2021-02-22 09:53:26 +0100levelset(493ffb86@c-73-63-251-134.hsd1.ca.comcast.net)
2021-02-22 09:53:37 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net)
2021-02-22 09:55:32 +0100jedws(~jedws@101.184.202.248)
2021-02-22 09:56:33 +0100 <levelset> I'm stuck on a nice way to write a function of type `Monad m => ((a -> b) -> a -> b) -> ((a -> m b) -> a -> m b)`. It feels like it should be fairly straightforward, but the best I've come up with is https://pastebin.com/CFFYBcGq?fbclid=IwAR0sWGhjZrqvLekuWffFd_IG1haeXJywWtPQMsZYKM3xEE1BDxBezT6Kpx0, which seems pretty weird. Any suggestions?
2021-02-22 09:57:52 +0100 <levelset> (I don't think this is a good idea, per se, it just feels like it should be a super easy composition of some existing abstractions and I haven't found them)
2021-02-22 09:59:08 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec)
2021-02-22 09:59:10 +0100acidjnk_new(~acidjnk@p200300d0c739095610730469cbb40c42.dip0.t-ipconnect.de)
2021-02-22 10:00:06 +0100psamim(samimpmatr@gateway/shell/matrix.org/x-aphqpdlhwcwoigrn) (Quit: Idle for 30+ days)
2021-02-22 10:00:14 +0100pedrorubster[m](pedrorubst@gateway/shell/matrix.org/x-rtcodsrzxgzhwyyh) (Quit: Idle for 30+ days)
2021-02-22 10:00:14 +0100Vanilla[m](danielm14@gateway/shell/matrix.org/x-axifdmrqergkcrjc) (Quit: Idle for 30+ days)
2021-02-22 10:00:43 +0100frozenErebus(~frozenEre@94.128.219.166)
2021-02-22 10:00:52 +0100 <edwardk> @djinn Monad m => ((a -> b) -> a -> b) -> ((a -> m b) -> a -> m b)
2021-02-22 10:00:52 +0100 <lambdabot> f _ a b = a b
2021-02-22 10:00:56 +0100 <edwardk> thanks djinn. ;)
2021-02-22 10:01:47 +0100WarzoneCommand(~Frank@77-162-168-71.fixed.kpn.net)
2021-02-22 10:01:55 +0100 <levelset> it tried its best
2021-02-22 10:02:08 +0100 <edwardk> so my question do you is this. how do you expect to pass an action from a -> m b to a function that only takes (a -> b) for its first argument?
2021-02-22 10:02:14 +0100 <edwardk> i mean, it gave the only correct answer here
2021-02-22 10:03:54 +0100 <levelset> That is an extremely good point
2021-02-22 10:04:17 +0100 <edwardk> just look at things step by step. you have a function f : (a -> b) -> a -> b, mf : a -> m b, and an x : a. you can feed mf x : m b. but that isn't what it looks like you are trying to do. if i saw that signature i'd see you wanted to pass (a -> m b) in as f's first argument and pass x as its second. but f is too crippled.
2021-02-22 10:04:45 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber) (Ping timeout: 265 seconds)
2021-02-22 10:05:30 +0100 <edwardk> your approximation makes a bit assumption that makes it non-canonical: more or elss that the a passed into the (a -> b) in (a -> b) -> a -> b doesn't matter at all, and/or that it is x
2021-02-22 10:05:36 +0100frozenErebus(~frozenEre@94.128.219.166) (Ping timeout: 240 seconds)
2021-02-22 10:05:48 +0100 <edwardk> i call that function cursed
2021-02-22 10:06:56 +0100whald(~trem@ip4d1582ab.dynamic.kabel-deutschland.de)
2021-02-22 10:07:45 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 264 seconds)
2021-02-22 10:07:46 +0100 <levelset> Yeah, you definitely read my intent correctly. I was hoping that there would be some bit of alebraically-equivalent something something that would let me turn the function in question inside out so I could use the regular monad tools on it to do the lift, but "no there isn't" is a completely valid resolution
2021-02-22 10:08:16 +0100minoru_shiraeesh(~shiraeesh@109.166.57.22) (Ping timeout: 240 seconds)
2021-02-22 10:08:31 +0100 <levelset> Thank you!
2021-02-22 10:09:53 +0100hendursa1(~weechat@gateway/tor-sasl/hendursaga)
2021-02-22 10:10:03 +0100 <edwardk> levelset: there kinda is
2021-02-22 10:10:11 +0100 <edwardk> you need to cheat more though
2021-02-22 10:10:13 +0100 <edwardk> consider
2021-02-22 10:10:39 +0100 <edwardk> Monad m => (forall m'. Monad m' => (a -> m' b) -> a -> m' b) -> ((a -> m b) -> a -> m b)
2021-02-22 10:10:45 +0100 <edwardk> that looks like i didn't do anything
2021-02-22 10:10:50 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-22 10:10:56 +0100 <edwardk> but now that first argument isn't allowed to use the monad effects of 'm' at all
2021-02-22 10:10:58 +0100hendursaga(~weechat@gateway/tor-sasl/hendursaga) (Ping timeout: 268 seconds)
2021-02-22 10:11:05 +0100kritzefitz(~kritzefit@fw-front.credativ.com) (Ping timeout: 240 seconds)
2021-02-22 10:11:10 +0100 <edwardk> all it can do is plumb it through and use >>= and return like a good little boy
2021-02-22 10:11:31 +0100 <edwardk> that means you can know that the call to (a -> m b) you feed it is the source of _all_ monadic effects in m inside that function.
2021-02-22 10:12:17 +0100 <edwardk> levelset: i exploited this approach in this article: http://comonad.com/reader/2011/searching-infinity/
2021-02-22 10:12:29 +0100jedws(~jedws@101.184.202.248) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 10:12:41 +0100 <edwardk> (it predates the AMP, so applicative wasn't yet a superclass of monad, ignore that part)
2021-02-22 10:13:49 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta)
2021-02-22 10:14:01 +0100bitmagie(~Thunderbi@200116b8066311005c3e5c1bf8f86d77.dip.versatel-1u1.de) (Quit: bitmagie)
2021-02-22 10:14:17 +0100 <edwardk> and it enjoys a delightfully simple implementation. foo f mf x = f mf x
2021-02-22 10:15:15 +0100 <edwardk> but in general if i want to require that i plumb someone else's effects through that quantification over the monad trick works pretty well
2021-02-22 10:15:54 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net)
2021-02-22 10:16:23 +0100 <desophos> Axman6, redirecting `verboseCheck` into a file actually allowed me to simplify my code quite a lot, so thank you!
2021-02-22 10:16:23 +0100 <levelset> That's a great trick!
2021-02-22 10:17:25 +0100leo__(~leo@cpc96810-rdng27-2-0-cust409.15-3.cable.virginm.net)
2021-02-22 10:18:30 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 256 seconds)
2021-02-22 10:19:25 +0100hiew(3dded63f@61-222-214-63.HINET-IP.hinet.net) (Quit: Connection closed)
2021-02-22 10:20:05 +0100 <tomsmeding> edwardk: at that point I'm not sure whether the new 'foo' function is really useful at all :p
2021-02-22 10:20:12 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net) (Ping timeout: 256 seconds)
2021-02-22 10:20:33 +0100 <tomsmeding> :t \f mf x -> f mf x
2021-02-22 10:20:34 +0100 <lambdabot> (t1 -> t2 -> t3) -> t1 -> t2 -> t3
2021-02-22 10:20:39 +0100 <edwardk> tomsmeding: the key is that you can trust that the function you call as the first argument knows nothing about m, and so has to not use anything other than >>= on its own
2021-02-22 10:20:44 +0100 <edwardk> the rank n type is the key here
2021-02-22 10:21:04 +0100 <tomsmeding> I know, but at this point the function doesn't do anything anymore, and also has a much more generic type :p
2021-02-22 10:21:06 +0100 <edwardk> that argument has to work for _all_ choices of m. the other arguments get to know m
2021-02-22 10:21:27 +0100 <edwardk> it does something, which is rule out a function that knows its working with state. it gives you type errors if the first function cheats
2021-02-22 10:21:46 +0100 <tomsmeding> oh! good point
2021-02-22 10:21:49 +0100 <edwardk> its no more useless than using data Pair a = Pair a a as an argument to be more precise than passing an arbitrary [a]
2021-02-22 10:21:59 +0100 <tomsmeding> yes I see :)
2021-02-22 10:22:38 +0100 <edwardk> i use parametricity to rule out lots of cheating. its one of my favorite tools
2021-02-22 10:22:50 +0100 <edwardk> AD, reflection, etc.
2021-02-22 10:23:28 +0100jedws(~jedws@101.184.202.248)
2021-02-22 10:23:35 +0100pera(~pera@unaffiliated/pera)
2021-02-22 10:24:44 +0100heatsink(~heatsink@2600:1700:bef1:5e10:197a:8f1e:d522:cd3a)
2021-02-22 10:24:50 +0100kritzefitz(~kritzefit@212.86.56.80)
2021-02-22 10:27:01 +0100luite(sid387799@gateway/web/irccloud.com/x-ohgaypzpftwfeuju)
2021-02-22 10:27:28 +0100stree(~stree@68.36.8.116) (Ping timeout: 265 seconds)
2021-02-22 10:29:26 +0100heatsink(~heatsink@2600:1700:bef1:5e10:197a:8f1e:d522:cd3a) (Ping timeout: 264 seconds)
2021-02-22 10:29:58 +0100x0oytF(5da276ea@93-162-118-234-dynamic.dk.customer.tdc.net)
2021-02-22 10:31:14 +0100lambda-11235(~lambda-11@2600:1700:7c70:4600:305f:2287:bde6:feb9) (Quit: Bye)
2021-02-22 10:35:18 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 10:38:00 +0100idhugo_(~idhugo@80-62-117-86-mobile.dk.customer.tdc.net) (Remote host closed the connection)
2021-02-22 10:40:00 +0100stree(~stree@68.36.8.116)
2021-02-22 10:46:31 +0100idhugo(~idhugo@80-62-117-86-mobile.dk.customer.tdc.net)
2021-02-22 10:47:07 +0100idhugo(~idhugo@80-62-117-86-mobile.dk.customer.tdc.net) (Remote host closed the connection)
2021-02-22 10:47:26 +0100idhugo(~idhugo@80-62-117-86-mobile.dk.customer.tdc.net)
2021-02-22 10:48:08 +0100desophos(~desophos@2601:249:1680:a570:d500:73bc:696a:d401) (Quit: Leaving)
2021-02-22 10:49:58 +0100ericsagn1(~ericsagne@2405:6580:0:5100:86fb:42bc:1428:8130) (Ping timeout: 258 seconds)
2021-02-22 10:51:40 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 268 seconds)
2021-02-22 10:54:19 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 10:54:42 +0100levelset(493ffb86@c-73-63-251-134.hsd1.ca.comcast.net) (Quit: Connection closed)
2021-02-22 10:56:58 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-axacivxcvkkvhqtx) (Quit: Connection closed for inactivity)
2021-02-22 10:57:21 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus)
2021-02-22 10:57:39 +0100 <tomsmeding> I have a question about parallelism. Consider this code: https://paste.tomsmeding.com/dgYMPDCf . I provide the program with the input '1000000000 1000000000 1000000000\n1000000000 1000000000 1000000000\n' (six times 10^9; not hard-coded to eliminate optimisations as a source of weirdness). My machine runs one such loop in 1.44 seconds, and running the full thing predictably takes 8.6 ~= 6 * 1.44
2021-02-22 10:57:40 +0100 <tomsmeding> seconds normally. Passing +RTS -N2 makes it take 5.7 ~= 4 * 1.44 seconds, which is expected since both sets of three computations can be computed in the time of two. However, passing +RTS -N3 makes it sometimes take 2.88 (twice 1.44) and sometimes take 4.3 (three times 1.44) seconds; why is this inconsistent? How can this take 4.3 seconds?
2021-02-22 10:57:59 +0100 <tomsmeding> all times are wall clock times
2021-02-22 10:58:16 +0100 <tomsmeding> Note that -qg makes no difference to these observations; it does impact cpu time of course
2021-02-22 10:59:12 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 246 seconds)
2021-02-22 11:00:53 +0100jedws(~jedws@101.184.202.248) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 11:02:16 +0100ericsagn1(~ericsagne@2405:6580:0:5100:d940:32bf:aa80:d462)
2021-02-22 11:02:42 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 246 seconds)
2021-02-22 11:04:06 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 11:06:19 +0100oisdk(~oisdk@2001:bb6:3329:d100:c73:1525:4623:7479)
2021-02-22 11:07:56 +0100darjeeling_(~darjeelin@122.245.217.214) (Ping timeout: 240 seconds)
2021-02-22 11:08:54 +0100clog(~nef@bespin.org)
2021-02-22 11:09:22 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-02-22 11:09:27 +0100darjeeling_(~darjeelin@122.245.217.214)
2021-02-22 11:09:45 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 11:09:49 +0100danso(~dan@2001:1970:52e7:d000:96b8:6dff:feb3:c009) (Ping timeout: 272 seconds)
2021-02-22 11:10:16 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-02-22 11:11:09 +0100gzj(~gzj@unaffiliated/gzj) (Remote host closed the connection)
2021-02-22 11:11:30 +0100gzj(~gzj@unaffiliated/gzj)
2021-02-22 11:12:22 +0100xff0x(~xff0x@2001:1a81:52fd:ec00:30b:4057:d2b:135) (Ping timeout: 260 seconds)
2021-02-22 11:12:59 +0100xff0x(~xff0x@2001:1a81:52fd:ec00:624b:a459:3f1:35ff)
2021-02-22 11:14:58 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-02-22 11:15:36 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 11:18:48 +0100mrchampion(~mrchampio@38.18.109.23) (Ping timeout: 246 seconds)
2021-02-22 11:18:54 +0100GreyFaceNoSpace(~omar@95.157.26.203) (Quit: Ex-Chat)
2021-02-22 11:18:55 +0100xcmw(~textual@dyn-72-33-2-47.uwnet.wisc.edu) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 11:19:34 +0100danso(~dan@2001:1970:52e7:d000:96b8:6dff:feb3:c009)
2021-02-22 11:19:52 +0100mrchampion(~mrchampio@38.18.109.23)
2021-02-22 11:20:03 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh)
2021-02-22 11:20:50 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-02-22 11:21:21 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 11:22:02 +0100 <Uniaika> merijn: http://jamesrwilcox.com/runtime.html
2021-02-22 11:26:00 +0100heatsink(~heatsink@2600:1700:bef1:5e10:197a:8f1e:d522:cd3a)
2021-02-22 11:27:01 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 272 seconds)
2021-02-22 11:27:16 +0100 <tomsmeding> (except that I've seen people use spelling 3 for usage 2)
2021-02-22 11:27:18 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 11:30:38 +0100heatsink(~heatsink@2600:1700:bef1:5e10:197a:8f1e:d522:cd3a) (Ping timeout: 264 seconds)
2021-02-22 11:31:02 +0100 <tomsmeding> about my parallelism issue: -N4 has the same behaviour as -N3, in case you were wondering
2021-02-22 11:32:41 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-02-22 11:33:21 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 11:33:26 +0100saitamaplus(uid272474@gateway/web/irccloud.com/x-dfxujuraamaironk) (Quit: Connection closed for inactivity)
2021-02-22 11:36:16 +0100kritzefitz(~kritzefit@212.86.56.80) (Ping timeout: 240 seconds)
2021-02-22 11:36:35 +0100kritzefitz(~kritzefit@fw-front.credativ.com)
2021-02-22 11:38:46 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-02-22 11:39:18 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 11:44:08 +0100thc202(~thc202@unaffiliated/thc202)
2021-02-22 11:44:16 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-22 11:45:09 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 11:45:19 +0100viluon(uid453725@gateway/web/irccloud.com/x-ytvknempinpnbtej)
2021-02-22 11:46:13 +0100DavidEichmann(~david@234.109.45.217.dyn.plus.net)
2021-02-22 11:47:28 +0100pera(~pera@unaffiliated/pera) (Ping timeout: 256 seconds)
2021-02-22 11:48:59 +0100pera(~pera@unaffiliated/pera)
2021-02-22 11:49:59 +0100ukari(~ukari@unaffiliated/ukari) (Remote host closed the connection)
2021-02-22 11:50:26 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-02-22 11:50:40 +0100jedws(~jedws@101.184.202.248)
2021-02-22 11:50:42 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 11:50:59 +0100ukari(~ukari@unaffiliated/ukari)
2021-02-22 11:53:38 +0100bitmagie(~Thunderbi@200116b8066311005c3e5c1bf8f86d77.dip.versatel-1u1.de)
2021-02-22 11:54:26 +0100x0oytF(5da276ea@93-162-118-234-dynamic.dk.customer.tdc.net) (Quit: Connection closed)
2021-02-22 11:55:36 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-22 11:56:27 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 11:57:11 +0100sMuNiX(~sMuNiX@lnsm2-montreal02-142-118-236-120.internet.virginmobile.ca) (Read error: Connection reset by peer)
2021-02-22 11:59:15 +0100forgottenone(~forgotten@176.42.18.230)
2021-02-22 12:00:43 +0100ddellacosta(~ddellacos@86.106.143.46)
2021-02-22 12:01:02 +0100sMuNiX(~sMuNiX@lnsm2-montreal02-142-118-236-120.internet.virginmobile.ca)
2021-02-22 12:01:13 +0100__monty__(~toonn@unaffiliated/toonn)
2021-02-22 12:01:30 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 246 seconds)
2021-02-22 12:02:12 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 12:04:56 +0100ddellacosta(~ddellacos@86.106.143.46) (Ping timeout: 240 seconds)
2021-02-22 12:06:17 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex) (Ping timeout: 268 seconds)
2021-02-22 12:07:42 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:b8ec:9dfb:e531:1ee7:9134) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 12:07:44 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex)
2021-02-22 12:07:45 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-02-22 12:07:57 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 12:09:03 +0100ania123(5e89ad7c@94.137.173.124)
2021-02-22 12:09:08 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-02-22 12:09:26 +0100 <ski> yea, rank-2 can be used for implementation hiding, to enforce a callback doesn't mess with some privates you pass through it
2021-02-22 12:10:06 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 12:10:08 +0100trafaret1(~user@178.207.171.111)
2021-02-22 12:11:32 +0100hexfive(~hexfive@50.35.83.177) (Quit: i must go. my people need me.)
2021-02-22 12:12:55 +0100 <kuribas> and it gives a cleaner signature
2021-02-22 12:14:45 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2021-02-22 12:15:59 +0100son0p(~son0p@181.58.39.182)
2021-02-22 12:17:27 +0100ania123(5e89ad7c@94.137.173.124) (Quit: Connection closed)
2021-02-22 12:18:04 +0100ania123(5e89ad7c@94.137.173.124)
2021-02-22 12:18:58 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 272 seconds)
2021-02-22 12:19:18 +0100neiluj(~jco@unaffiliated/neiluj) (Quit: leaving)
2021-02-22 12:19:27 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 12:20:56 +0100loller_(uid358106@gateway/web/irccloud.com/x-kbcihpyfexgxmziw) (Quit: Connection closed for inactivity)
2021-02-22 12:24:35 +0100chisui(588298ad@88.130.152.173)
2021-02-22 12:24:36 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-22 12:24:42 +0100 <ph88> tomsmeding, in the foldl the result depends on the last iteration no ?
2021-02-22 12:25:12 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 12:25:18 +0100dibblego(~dibblego@haskell/developer/dibblego) (Ping timeout: 272 seconds)
2021-02-22 12:25:57 +0100jedws(~jedws@101.184.202.248) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 12:26:42 +0100heatsink(~heatsink@2600:1700:bef1:5e10:197a:8f1e:d522:cd3a)
2021-02-22 12:27:59 +0100usr25(~usr25@unaffiliated/usr25)
2021-02-22 12:29:29 +0100ania123(5e89ad7c@94.137.173.124) (Quit: Connection closed)
2021-02-22 12:30:22 +0100dibblego(~dibblego@122-199-1-30.ip4.superloop.com)
2021-02-22 12:30:22 +0100dibblego(~dibblego@122-199-1-30.ip4.superloop.com) (Changing host)
2021-02-22 12:30:22 +0100dibblego(~dibblego@haskell/developer/dibblego)
2021-02-22 12:30:34 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-02-22 12:31:03 +0100wei2912(~wei2912@unaffiliated/wei2912) (Remote host closed the connection)
2021-02-22 12:31:12 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 12:31:12 +0100ukari(~ukari@unaffiliated/ukari) (Remote host closed the connection)
2021-02-22 12:31:14 +0100heatsink(~heatsink@2600:1700:bef1:5e10:197a:8f1e:d522:cd3a) (Ping timeout: 264 seconds)
2021-02-22 12:31:49 +0100evandocarmo(2f0e0036@047-014-000-054.res.spectrum.com)
2021-02-22 12:32:17 +0100ukari(~ukari@unaffiliated/ukari)
2021-02-22 12:33:15 +0100 <evandocarmo> Hey! What's your guys' favorite tutorial for programmers of other languages trying to learn? I work with golang and typescript professionally, trying to pick up something different as a hobby/future investment
2021-02-22 12:33:41 +0100ddellacosta(~ddellacos@86.106.143.150)
2021-02-22 12:33:53 +0100 <__monty__> @where cis194
2021-02-22 12:33:53 +0100 <lambdabot> https://www.seas.upenn.edu/~cis194/spring13/lectures.html
2021-02-22 12:33:57 +0100 <__monty__> This maybe?
2021-02-22 12:34:02 +0100 <evandocarmo> Looked into Scala but the ecosystem seemed a little too convoluted (at least coming from Go where everything is so straightforward)
2021-02-22 12:34:29 +0100 <evandocarmo> I'll look into it, thanks!
2021-02-22 12:34:42 +0100sMuNiX(~sMuNiX@lnsm2-montreal02-142-118-236-120.internet.virginmobile.ca) (Quit: WeeChat 3.0.1)
2021-02-22 12:34:51 +0100 <__monty__> Haskell tends not to have designated libraries for doing stuff. There's pretty much always options. If you consider that convoluted maybe haskell's no better.
2021-02-22 12:36:16 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-22 12:36:42 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 12:38:05 +0100ddellacosta(~ddellacos@86.106.143.150) (Ping timeout: 240 seconds)
2021-02-22 12:38:29 +0100 <evandocarmo> Yeah maybe I'm just spoiled. That tutorial seems pretty easy to digest though, so I'll try to go over it. thanks again!
2021-02-22 12:38:43 +0100ania123(5e89ad7c@94.137.173.124)
2021-02-22 12:38:58 +0100 <__monty__> Good luck! And not having choices is the opposite of being spoiled, imo : )
2021-02-22 12:39:52 +0100kam1(~kam1@37.129.135.98)
2021-02-22 12:40:55 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 12:41:45 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 246 seconds)
2021-02-22 12:42:28 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 12:44:30 +0100sMuNiX(~sMuNiX@lnsm2-montreal02-142-118-236-120.internet.virginmobile.ca)
2021-02-22 12:45:45 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2021-02-22 12:46:25 +0100kam1(~kam1@37.129.135.98) (Ping timeout: 240 seconds)
2021-02-22 12:47:56 +0100stree(~stree@68.36.8.116) (Ping timeout: 240 seconds)
2021-02-22 12:48:07 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-02-22 12:48:24 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 12:48:25 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:b8ec:9dfb:e531:1ee7:9134)
2021-02-22 12:50:05 +0100Deide(~Deide@217.155.19.23)
2021-02-22 12:53:57 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-02-22 12:54:09 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 12:56:20 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 272 seconds)
2021-02-22 12:57:00 +0100 <tomsmeding> ph88: yes, the accumulator (and thus result) type of the foldl' is an Int, so seq'ing that forces the entire computation, so the loop is strict
2021-02-22 12:57:39 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-22 12:58:33 +0100chisui(588298ad@88.130.152.173) (Quit: Connection closed)
2021-02-22 12:59:00 +0100 <kuribas> I don't find the ecosystems of different languages better in significant ways, including haskell.
2021-02-22 13:00:49 +0100 <ania123> how can I convert words written in 8 digit decimal to 2 digits decimal ?
2021-02-22 13:00:56 +0100 <kuribas> Each one has their warts.
2021-02-22 13:01:09 +0100 <kuribas> But haskell is a significantly cleaner language than scala.
2021-02-22 13:01:32 +0100stree(~stree@68.36.8.116)
2021-02-22 13:01:33 +0100 <Squarism> I guess this is something I should know by know, but how do you sort a tree? I guess it involves Traversable?
2021-02-22 13:01:46 +0100 <dminuoso> Squarism: It's not a generically available operation.
2021-02-22 13:02:09 +0100 <kuribas> Squarism: what kind of tree?
2021-02-22 13:02:15 +0100 <kuribas> what kind of sorting?
2021-02-22 13:02:54 +0100 <__monty__> ania123: You can't write "12000000" with only two digits.
2021-02-22 13:02:57 +0100 <Squarism> Rosetree as in Data.Tree a. And sorting is just alphabetic using an accessor on "a"
2021-02-22 13:03:17 +0100 <ania123> I need an algorithm which does it...
2021-02-22 13:03:43 +0100 <dminuoso> Squarism: What does sorting mean, exactly, then?
2021-02-22 13:03:44 +0100 <ania123> takes words written with 8 digit decimals and convers two digit decimals
2021-02-22 13:03:56 +0100trafaret1(~user@178.207.171.111) ("ERC (IRC client for Emacs 26.3)")
2021-02-22 13:03:57 +0100 <ania123> can I find that alg somewhere in internet?
2021-02-22 13:04:09 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-02-22 13:04:22 +0100 <kuribas> ania123: what's a 8 digit decimal?
2021-02-22 13:04:23 +0100 <Squarism> dminuoso, children sorted alphabetically on at any level
2021-02-22 13:04:31 +0100 <Squarism> at ant*
2021-02-22 13:04:35 +0100 <Squarism> any*
2021-02-22 13:04:38 +0100 <dminuoso> Squarism: Oh, so you want to just sort the child lists in each node?
2021-02-22 13:04:45 +0100 <__monty__> ania123: No, because it's not possible. You'll have to specify what you want in a lot more detail.
2021-02-22 13:04:50 +0100 <Squarism> dminuoso, yes
2021-02-22 13:04:55 +0100fendor_fendor
2021-02-22 13:05:27 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 13:05:41 +0100 <kuribas> ania123: an octal number? You want to convert from octal to binary?
2021-02-22 13:05:44 +0100 <dminuoso> Squarism: That's just a small two liner then.
2021-02-22 13:06:16 +0100 <ania123> kuribas
2021-02-22 13:06:20 +0100 <ania123> exactly
2021-02-22 13:06:26 +0100 <ania123> I need to design an algorithm which does it
2021-02-22 13:06:39 +0100 <dminuoso> Well. Single liner, even
2021-02-22 13:06:54 +0100 <dminuoso> sortTreeOn f (Node x cs) = {- left as an excercise -}
2021-02-22 13:06:56 +0100 <kuribas> ania123: ok, so what's the problem then?
2021-02-22 13:07:16 +0100 <ania123> can I find alg for it?
2021-02-22 13:07:25 +0100 <kuribas> is this homework?
2021-02-22 13:07:34 +0100 <[exa]> ania123: the people are trying to imply that you should think for 5 minutes until it's obvious
2021-02-22 13:07:58 +0100 <__monty__> ania123: Can you come up with a way to convert a single octit to a string of bits?
2021-02-22 13:09:36 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 240 seconds)
2021-02-22 13:10:21 +0100 <Squarism> dminuoso ... = Node x $ fmap (sortTreeOn f) cs
2021-02-22 13:10:24 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta)
2021-02-22 13:10:25 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-22 13:10:53 +0100 <Squarism> i thought there was some combination traverse traverse thingy
2021-02-22 13:10:55 +0100natechan(~natechan@108-233-125-227.lightspeed.sntcca.sbcglobal.net) (Read error: Connection reset by peer)
2021-02-22 13:11:12 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 13:11:20 +0100rdivyanshu(uid322626@gateway/web/irccloud.com/x-tworbfpnkgwjjhuq)
2021-02-22 13:11:30 +0100 <ania123> kuribas : it is an assignment discussed in the class...
2021-02-22 13:11:36 +0100ania123(5e89ad7c@94.137.173.124) (Quit: Connection closed)
2021-02-22 13:11:42 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 13:11:54 +0100natechan(~natechan@108-233-125-227.lightspeed.sntcca.sbcglobal.net)
2021-02-22 13:11:56 +0100runawayfive(~nope@unaffiliated/runawayfive) (Ping timeout: 240 seconds)
2021-02-22 13:12:01 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-22 13:12:04 +0100 <dminuoso> Squarism: Nothing as concise comes to mind.
2021-02-22 13:12:19 +0100 <dminuoso> Squarism: Also note, you're still missing a crucial part there.
2021-02-22 13:12:59 +0100ania123(5e89ad7c@94.137.173.124)
2021-02-22 13:13:11 +0100 <ania123> sorry disconected ...
2021-02-22 13:13:34 +0100puke(~vroom@217.138.252.206) (Quit: puke)
2021-02-22 13:14:05 +0100 <__monty__> ania123: Can you come up with a function toBit :: Char -> [Char]? Where the input is a single octal digit and the output is a string of binary digits?
2021-02-22 13:14:53 +0100 <ania123> I think, I am unable
2021-02-22 13:14:54 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 260 seconds)
2021-02-22 13:15:47 +0100chisui(588298ad@88.130.152.173)
2021-02-22 13:16:16 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-22 13:16:46 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2021-02-22 13:16:49 +0100 <__monty__> ania123: Ok, do you understand how to convert an octit to bits?
2021-02-22 13:16:54 +0100ski. o O ( "Cogito, erge nescius." )
2021-02-22 13:16:57 +0100 <swarmcollective> anial23, you could think of it like this: what are the possible values of an octal digit? Now, what are the possible values of a binary digit?
2021-02-22 13:17:15 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 13:19:16 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2021-02-22 13:19:39 +0100runawayfive(~nope@unaffiliated/runawayfive)
2021-02-22 13:19:40 +0100ania123(5e89ad7c@94.137.173.124) (Quit: Connection closed)
2021-02-22 13:22:16 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-22 13:22:19 +0100puke(~vroom@217.138.252.56)
2021-02-22 13:22:48 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 13:23:54 +0100Stanley00(~stanley00@unaffiliated/stanley00) (Remote host closed the connection)
2021-02-22 13:25:27 +0100jdsharp(~jdsharp@185.163.110.108) (Remote host closed the connection)
2021-02-22 13:26:04 +0100 <ph88> tomsmeding, how you expect that to speed up over multiple cores ?
2021-02-22 13:27:43 +0100heatsink(~heatsink@2600:1700:bef1:5e10:197a:8f1e:d522:cd3a)
2021-02-22 13:29:08 +0100drbean_(~drbean@TC210-63-209-168.static.apol.com.tw)
2021-02-22 13:31:47 +0100urodna(~urodna@unaffiliated/urodna)
2021-02-22 13:31:56 +0100heatsink(~heatsink@2600:1700:bef1:5e10:197a:8f1e:d522:cd3a) (Ping timeout: 240 seconds)
2021-02-22 13:35:57 +0100ph88(~ph88@ip5f5af71a.dynamic.kabel-deutschland.de) (Ping timeout: 264 seconds)
2021-02-22 13:36:12 +0100usr25(~usr25@unaffiliated/usr25) (Quit: Leaving)
2021-02-22 13:36:39 +0100ph88(~ph88@ip5f5af71a.dynamic.kabel-deutschland.de)
2021-02-22 13:38:32 +0100 <tomsmeding> ph88: I'm evaluating three of those folds, and they're independent
2021-02-22 13:38:42 +0100 <tomsmeding> so I'm expecting that to speed up over three threads :p
2021-02-22 13:38:47 +0100 <tomsmeding> and it does -- usually
2021-02-22 13:38:56 +0100 <tomsmeding> the "usually" is what surprises me
2021-02-22 13:39:47 +0100berberman_(~berberman@unaffiliated/berberman) (Ping timeout: 258 seconds)
2021-02-22 13:40:56 +0100berberman(~berberman@unaffiliated/berberman)
2021-02-22 13:41:53 +0100minoru_shiraeesh(~shiraeesh@109.166.57.27)
2021-02-22 13:42:03 +0100 <dminuoso> tomsmeding: Mmm, did you ThreadScope it?
2021-02-22 13:42:18 +0100 <tomsmeding> dminuoso: I didn't
2021-02-22 13:42:28 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 13:42:56 +0100tomsmeding$ cabal install threadscope
2021-02-22 13:43:09 +0100 <merijn> tomsmeding: What was the code?
2021-02-22 13:43:25 +0100 <tomsmeding> merijn: https://paste.tomsmeding.com/dgYMPDCf
2021-02-22 13:43:45 +0100 <tomsmeding> the problem is not unique to the async library though
2021-02-22 13:43:52 +0100 <tomsmeding> it just makes the example shorter
2021-02-22 13:44:11 +0100gzj(~gzj@unaffiliated/gzj) (Remote host closed the connection)
2021-02-22 13:44:31 +0100 <merijn> tomsmeding: That hacky seq makes me suspificous
2021-02-22 13:44:48 +0100 <tomsmeding> merijn: how would you write it instead?
2021-02-22 13:45:08 +0100 <merijn> @hackage deepseq
2021-02-22 13:45:08 +0100 <lambdabot> https://hackage.haskell.org/package/deepseq
2021-02-22 13:45:21 +0100 <tomsmeding> oh sure, deepseq does not fix the problem
2021-02-22 13:46:12 +0100 <ph88> tomsmeding, i only see 3 folds where is the 4rd ?
2021-02-22 13:46:17 +0100 <ph88> 3rd
2021-02-22 13:46:29 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 13:46:46 +0100 <dminuoso> Also, I wish I could have a bit more impredicativity. [(Text, forall s. ToField s => s)] is exactly what I want right now. :(
2021-02-22 13:46:51 +0100jamm_(~jamm@unaffiliated/jamm)
2021-02-22 13:47:16 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2021-02-22 13:47:25 +0100 <tomsmeding> ph88: I read two lists of numbers from input; each of the numbers is processed by one fold
2021-02-22 13:47:33 +0100 <merijn> tomsmeding: Oh, you're not adding type annotations for Int
2021-02-22 13:47:41 +0100 <merijn> tomsmeding: Is it being inferred as Integer maybe?
2021-02-22 13:47:41 +0100 <tomsmeding> the two lists are sequential, but within one list I want to run the folds in parallel
2021-02-22 13:47:48 +0100 <tomsmeding> merijn: see the ':: [[Int]]'
2021-02-22 13:47:55 +0100 <tomsmeding> also I compile with -Wall and there are no warnings
2021-02-22 13:48:09 +0100 <merijn> Anyway
2021-02-22 13:48:20 +0100 <merijn> mapConcurrently is a pretty big hammer
2021-02-22 13:48:30 +0100 <merijn> How big are your lists?
2021-02-22 13:48:36 +0100 <merijn> i.e. how many ints are you folding?
2021-02-22 13:48:37 +0100 <tomsmeding> 15 or so
2021-02-22 13:48:57 +0100 <tomsmeding> the fold is just an example workload though, but it's small and exhibits the same problem
2021-02-22 13:49:04 +0100 <tomsmeding> as my real workload
2021-02-22 13:49:07 +0100 <merijn> tomsmeding: oh
2021-02-22 13:49:08 +0100 <merijn> tomsmeding: Yeah
2021-02-22 13:49:17 +0100evandocarmo(2f0e0036@047-014-000-054.res.spectrum.com) (Quit: Connection closed)
2021-02-22 13:49:17 +0100 <merijn> tomsmeding: You're never going to see meaningful speedup
2021-02-22 13:49:29 +0100 <tomsmeding> merijn: look again
2021-02-22 13:49:37 +0100 <tomsmeding> each list item produces a fold that runs for 1.44 seconds
2021-02-22 13:49:41 +0100 <tomsmeding> and each of those folds is independent
2021-02-22 13:49:56 +0100 <tomsmeding> I'm expecting a list of 15 items to pin 15 cores for 1.44 seconds, approximately
2021-02-22 13:50:02 +0100 <merijn> I don't see results?
2021-02-22 13:50:04 +0100 <ph88> tomsmeding, how you figure that would speed of over 3 cores though ? still don't get it or see a 3rd fold
2021-02-22 13:50:22 +0100 <tomsmeding> ph88: values1 and values2 have length 3
2021-02-22 13:50:33 +0100 <merijn> tomsmeding: Do you actually have 15 capabilities running?
2021-02-22 13:50:48 +0100frozenErebus(~frozenEre@94.128.219.166)
2021-02-22 13:51:00 +0100 <tomsmeding> my test lists (values1 and values2) here are length 3, and I'm passing -N3 or -N4 -- no difference between those two
2021-02-22 13:51:04 +0100 <dminuoso> tomsmeding: I'd wait for ThreadScope results
2021-02-22 13:51:10 +0100 <dminuoso> So we dont have to guess what your capabilities are doing
2021-02-22 13:51:16 +0100 <merijn> tomsmeding: Oh
2021-02-22 13:51:19 +0100 <merijn> tomsmeding: Also
2021-02-22 13:51:20 +0100 <tomsmeding> I'm now going to run threadscope, just compiled :)
2021-02-22 13:51:24 +0100 <merijn> tomsmeding: You're not doing -qg
2021-02-22 13:51:33 +0100 <tomsmeding> merijn: makes no difference
2021-02-22 13:51:51 +0100 <tomsmeding> adding -qg reduces cpu time, but not wall clock time
2021-02-22 13:52:03 +0100 <tomsmeding> (in my real application I'm using -qg)
2021-02-22 13:52:07 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Quit: mputz)
2021-02-22 13:52:18 +0100Tario(~Tario@201.192.165.173)
2021-02-22 13:52:22 +0100LKoen_(~LKoen@252.248.88.92.rev.sfr.net)
2021-02-22 13:53:42 +0100ukari(~ukari@unaffiliated/ukari) (Remote host closed the connection)
2021-02-22 13:53:45 +0100 <Squarism> dminuoso, oh, sure. The sort part =D
2021-02-22 13:54:27 +0100ukari(~ukari@unaffiliated/ukari)
2021-02-22 13:54:34 +0100minoru_shiraeesh(~shiraeesh@109.166.57.27) (Ping timeout: 260 seconds)
2021-02-22 13:54:36 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net) (Ping timeout: 240 seconds)
2021-02-22 13:54:38 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-02-22 13:55:12 +0100 <tomsmeding> dminuoso: I have a "weird" run (where less than three folds run in parallel) in threadscope, and I'm seeing what I expect to see: only some of the threads are active https://tomsmeding.com/ss/get/tomsmeding/Yftmj0
2021-02-22 13:55:19 +0100 <tomsmeding> what should I be looking at?
2021-02-22 13:55:27 +0100ghais(ac3a030f@gateway/web/cgi-irc/kiwiirc.com/ip.172.58.3.15)
2021-02-22 14:02:20 +0100chisui(588298ad@88.130.152.173) (Quit: Connection closed)
2021-02-22 14:02:40 +0100chisui(588298ad@88.130.152.173)
2021-02-22 14:03:12 +0100 <merijn> oh, hah
2021-02-22 14:03:12 +0100Wuzzy(~Wuzzy@p57a2e7e5.dip0.t-ipconnect.de)
2021-02-22 14:03:14 +0100 <merijn> duh
2021-02-22 14:03:37 +0100 <merijn> mapConcurrently is running the effects in parallel
2021-02-22 14:03:57 +0100 <merijn> but your use of seq is forcing the (sequential) map to evaluate the entire fold before the effect is produced and can be ran
2021-02-22 14:03:59 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl)
2021-02-22 14:04:10 +0100 <merijn> Look at thread activity
2021-02-22 14:04:17 +0100 <merijn> They all start at 1.x offsets
2021-02-22 14:04:34 +0100 <merijn> Exactly as you'd expect for sequential execution
2021-02-22 14:04:37 +0100 <tomsmeding> merijn: but... I'm getting the expected (for me) parallel effects most of the time
2021-02-22 14:05:12 +0100 <tomsmeding> the point of the seq is that mapConcurrently will evaluate the effect in parallel, and that effect is the first thing that forces the fold
2021-02-22 14:05:20 +0100 <tomsmeding> thus I'm expecting the folds to evaluate in parallel
2021-02-22 14:05:44 +0100 <tomsmeding> that the 'print' later also forces the folds is irrelevant, I believe
2021-02-22 14:05:49 +0100 <tomsmeding> is my mental model wrong?
2021-02-22 14:06:27 +0100 <merijn> oh, wait
2021-02-22 14:06:35 +0100 <tomsmeding> I unfortunately have to go for a while
2021-02-22 14:06:57 +0100nut(~user@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2021-02-22 14:07:26 +0100 <tomsmeding> will be back later, thanks for your mental cycles you've spent on my problem already :)
2021-02-22 14:07:46 +0100 <__monty__> Maybe it just depends on where the threads get scheduled?
2021-02-22 14:08:00 +0100 <dminuoso> tomsmeding: Id look at the event log itself
2021-02-22 14:08:05 +0100 <dminuoso> (tab raw events)
2021-02-22 14:08:09 +0100 <merijn> __monty__: If you look at his threadscope you see the 2nd and 3rd threads don't start until after 1.2s
2021-02-22 14:08:24 +0100 <merijn> Which given his estimate of 1.4s runtime implies you're just running sequentially
2021-02-22 14:08:25 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl) (Client Quit)
2021-02-22 14:08:35 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-22 14:08:42 +0100son0p(~son0p@181.58.39.182) (Quit: leaving)
2021-02-22 14:08:56 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 14:09:23 +0100 <dminuoso> tomsmeding: Can you share the eventlog perhaps?
2021-02-22 14:09:25 +0100 <tomsmeding> merijn: how do you explain threads 2 and 3 running in parallel then, and threads 4, 5 and 6 too?
2021-02-22 14:09:30 +0100 <dminuoso> I cant reproduce it locally
2021-02-22 14:09:32 +0100geekosaur(82650c7a@130.101.12.122)
2021-02-22 14:09:41 +0100 <tomsmeding> dminuoso: in a while, sorry :(
2021-02-22 14:09:52 +0100 <dminuoso> No worries, it's your problem
2021-02-22 14:09:54 +0100 <dminuoso> ;)
2021-02-22 14:12:05 +0100frozenErebus(~frozenEre@94.128.219.166) (Ping timeout: 240 seconds)
2021-02-22 14:13:09 +0100ghais(ac3a030f@gateway/web/cgi-irc/kiwiirc.com/ip.172.58.3.15) (Ping timeout: 264 seconds)
2021-02-22 14:14:21 +0100 <dminuoso> intercalate :: [a] -> [[a]] -> [a]
2021-02-22 14:14:32 +0100 <dminuoso> Mmm, why is this constrained to [] - this should be generalized to Monoid on the inner list
2021-02-22 14:14:52 +0100 <dminuoso> Or is this just some case of "nobody has bothered before"?
2021-02-22 14:14:56 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-22 14:15:17 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 14:15:25 +0100 <dminuoso> Oh. The Haskell Reports demands it that way.
2021-02-22 14:16:25 +0100rzmt(~rzmt@87-92-180-112.rev.dnainternet.fi) (Ping timeout: 240 seconds)
2021-02-22 14:16:56 +0100sablib(~sablib@171.113.165.65)
2021-02-22 14:17:22 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:15cd:c67f:11dd:b9fc)
2021-02-22 14:17:26 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de)
2021-02-22 14:18:14 +0100Benzi-Junior(~BenziJuni@dsl-149-67-143.hive.is)
2021-02-22 14:19:04 +0100rzmt(~rzmt@87-92-180-112.rev.dnainternet.fi)
2021-02-22 14:22:53 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:15cd:c67f:11dd:b9fc) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 14:23:21 +0100cafce25(~cafce25@ipbcc3009d.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2021-02-22 14:24:34 +0100bitmapper(uid464869@gateway/web/irccloud.com/x-kljuzclzqvltjlcu)
2021-02-22 14:24:46 +0100ddellacosta(~ddellacos@86.106.143.124)
2021-02-22 14:25:27 +0100aggin(~ecm@103.88.87.38)
2021-02-22 14:26:23 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr)
2021-02-22 14:28:24 +0100gienah(~mwright@gentoo/developer/gienah)
2021-02-22 14:29:21 +0100ddellacosta(~ddellacos@86.106.143.124) (Ping timeout: 264 seconds)
2021-02-22 14:29:52 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2021-02-22 14:31:08 +0100aqd(~aqd@84.20.147.33)
2021-02-22 14:32:47 +0100son0p(~son0p@181.136.122.143)
2021-02-22 14:32:57 +0100Guest90(506fd516@gateway/web/cgi-irc/kiwiirc.com/ip.80.111.213.22)
2021-02-22 14:35:08 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-22 14:35:24 +0100 <int-e> :t length
2021-02-22 14:35:26 +0100 <lambdabot> Foldable t => t a -> Int
2021-02-22 14:35:28 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 14:35:30 +0100 <merijn> dminuoso: Deliver us from this mess!
2021-02-22 14:35:45 +0100 <int-e> dminuoso: not sure how much of an argument that is these days
2021-02-22 14:37:00 +0100 <kuribas> It's still compatible with it...
2021-02-22 14:37:23 +0100 <merijn> kuribas: No
2021-02-22 14:37:30 +0100 <merijn> Hasn't been for a decade :p
2021-02-22 14:37:30 +0100 <dminuoso> % intercalate :: (Monoid m, Foldable f) => m -> f m -> m; intercalate e = fold . intersperse e . toList
2021-02-22 14:37:30 +0100forgottenone(~forgotten@176.42.18.230) (Ping timeout: 260 seconds)
2021-02-22 14:37:31 +0100 <yahb> dminuoso:
2021-02-22 14:39:01 +0100 <kuribas> merijn: I mean the type with monoid can be compatible with the report version, not the same.
2021-02-22 14:39:30 +0100 <dminuoso> I suppose the primary argument against this generalized intercalate, is that overly generalized functions hinder the learning experience.
2021-02-22 14:39:32 +0100zaquest(~notzaques@5.128.210.178) (Quit: Leaving)
2021-02-22 14:40:15 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 256 seconds)
2021-02-22 14:40:25 +0100 <dminuoso> But, perhaps, we should have a sort of haskell report compat prelude, which contains all the monomorphized goodies and comes with separate haddock
2021-02-22 14:40:37 +0100 <swarmcollective> kuribas, I agree, but it seems as though a "This can be thought of as: ..." in the docs / comments would help mitigate that.
2021-02-22 14:41:38 +0100 <kuribas> I don't see why a language needs to be written to be easy for beginners...
2021-02-22 14:42:03 +0100 <kuribas> You can always present the beginner an simplified environment.
2021-02-22 14:42:37 +0100 <__monty__> It's an easy way to get users. "Python's great for beginners!" Now look at what havoc they have wreaked.
2021-02-22 14:42:39 +0100 <swarmcollective> Perhaps even a `verbose` mode for HLS to show the actual definition `m -> f m -> m` and the `[a] -> [[a]] -> [a]` that a beginner can enable as needed.\
2021-02-22 14:42:51 +0100 <kuribas> I think haskell already took that route with the Monad/Applicative/Functor proposal.
2021-02-22 14:43:21 +0100 <kuribas> And the many generalized functions in base.
2021-02-22 14:43:26 +0100 <dminuoso> __monty__: I guess its a difficult trade off. If you cater too much to your experienced users, the raised bar will lower adoption.
2021-02-22 14:43:34 +0100 <ski> Racket has "language levels", where the lower ones present a simpler language, and simpler, less general, operations
2021-02-22 14:43:47 +0100 <maerwald> kuribas: yeah, there were attempts at doing that with haskell, so you could only use parts of the language features and have to unlock. As a learning platform. I'm not sure how that project turned out.
2021-02-22 14:43:55 +0100 <dminuoso> ski: And Im sure this comes at an engineering price.
2021-02-22 14:43:56 +0100 <ski> @where Helium
2021-02-22 14:43:56 +0100 <lambdabot> http://www.cs.uu.nl/research/projects/helium/
2021-02-22 14:44:27 +0100 <dminuoso> I for one would like to see varying degrees of diagnostics levels, so I can tweak GHC for the odd error to tell me as much technical stuff as it can
2021-02-22 14:44:42 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 14:44:44 +0100 <dminuoso> (I dont mind the word "skolem", for instance)
2021-02-22 14:45:08 +0100skiprefers it
2021-02-22 14:45:27 +0100zaquest(~notzaques@5.128.210.178)
2021-02-22 14:45:34 +0100drbean_(~drbean@TC210-63-209-168.static.apol.com.tw) (Ping timeout: 265 seconds)
2021-02-22 14:45:34 +0100__monty__never remembers what it means
2021-02-22 14:45:36 +0100 <dminuoso> It's likely having multiple such diagnostics levels would be readily accepted (if we can get through the bike shedding of what those levels look like, and what the diagnostics should read)
2021-02-22 14:45:42 +0100 <dminuoso> Just needs someone to implement it.
2021-02-22 14:46:49 +0100 <dminuoso> __monty__: Do you find "rigid" to be helpful/meaningful?
2021-02-22 14:47:46 +0100 <__monty__> Might make it harder to help beginners though. Because experts are no longer familiar with the simple error messages. Which might then drive beginners who look for help regularly to just always turn on the complex messages.
2021-02-22 14:48:58 +0100 <__monty__> dminuoso: Not without context.
2021-02-22 14:51:06 +0100 <chibi> There's a lot of errors that're hard to figure out.
2021-02-22 14:51:26 +0100 <chibi> "Cannot construct the infinite type" is one particularly hellish one for begininers
2021-02-22 14:52:10 +0100 <merijn> Complaining about "bad" error messages is easy. Coming up with better one is *hard*
2021-02-22 14:52:50 +0100 <chibi> tru, tru
2021-02-22 14:52:51 +0100 <merijn> If you have better ideas on how to word error messages I'm very sure people in #ghc will be happy to hear your suggestions
2021-02-22 14:53:13 +0100Martinsos(~user@cpe-188-129-56-3.dynamic.amis.hr)
2021-02-22 14:53:22 +0100Guest90(506fd516@gateway/web/cgi-irc/kiwiirc.com/ip.80.111.213.22) (Ping timeout: 260 seconds)
2021-02-22 14:53:58 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 14:53:59 +0100 <Martinsos> I have a stack haskell project, and errors I get from my exe are:
2021-02-22 14:54:13 +0100 <Martinsos> wasp: /Users/matija/git/wasp-lang/wasp/waspc/examples/todoApp/ext/Todo.js~: openFile: does not exist (No such file or directory)
2021-02-22 14:54:25 +0100nut(~user@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 256 seconds)
2021-02-22 14:54:29 +0100 <Martinsos> wasp-bin: .../workspace/hello-wasp/MyNewApp/ext/waspLogo.png: copyFile:atomicCopyFileContents:withReplacementFile:copyFileToHandle:openBinaryFile: does not exist (No such file or directory)
2021-02-22 14:55:00 +0100 <Martinsos> Is there any way to get more information on these errors? Like proper stack trace? Especially the first one, where I get just openFile.
2021-02-22 14:55:39 +0100 <merijn> Is that an error from your code or from stack?
2021-02-22 14:55:49 +0100 <Martinsos> I tried using `stack build --profile` and then calling with `stack exec --profile -- wasp start +RTS -p` but that didn't change anything.
2021-02-22 14:56:01 +0100 <Martinsos> That is error from my code
2021-02-22 14:56:10 +0100 <merijn> Martinsos: You want "+RTS -xc" to get a stack trace from your profiled build
2021-02-22 14:56:27 +0100 <Martinsos> When calling exe or when compiling?
2021-02-22 14:56:31 +0100 <merijn> When calling
2021-02-22 14:56:45 +0100 <merijn> instead of "+RTS -p"
2021-02-22 14:56:58 +0100 <Martinsos> ok, so `stack build --profile` is ok, but I should do `stack exec --profile -- wasp start +RTS -xc`?
2021-02-22 14:57:06 +0100 <merijn> I think -p is just profiling, which is not what you want. -xc triggers stack traces on all thrown exceptions
2021-02-22 14:57:06 +0100swarmcollective(~joseph@cpe-65-31-18-174.insight.res.rr.com) (Ping timeout: 260 seconds)
2021-02-22 14:57:11 +0100 <merijn> Martinsos: Yeah
2021-02-22 14:57:18 +0100 <Martinsos> Ok awesome, will give it a try now!
2021-02-22 14:57:30 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-22 14:57:43 +0100swarmcollective(~joseph@cpe-65-31-18-174.insight.res.rr.com)
2021-02-22 14:57:44 +0100 <merijn> Martinsos: But it looks like your code is trying to access a temporary (emacs?) file
2021-02-22 14:57:51 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 14:57:58 +0100 <merijn> .js~ tildes are usually temporary editor files
2021-02-22 14:58:37 +0100lawr3nce(~lawr3nce@gateway/tor-sasl/lawr3nce)
2021-02-22 14:58:45 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2021-02-22 14:59:05 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl)
2021-02-22 14:59:05 +0100 <ski> (s/temporary/backup/, i guess)
2021-02-22 15:01:32 +0100geekosaurwas wondering if it was backing up some data file it's about to modify
2021-02-22 15:06:02 +0100cur8or(~cur8or@2c0f:fbe1:3:17:6d77:f5a5:800f:317) (Ping timeout: 264 seconds)
2021-02-22 15:06:46 +0100aggin(~ecm@103.88.87.38) (Quit: WeeChat 3.0.1)
2021-02-22 15:07:02 +0100aggin(~ecm@103.88.87.38)
2021-02-22 15:07:26 +0100thonkpod(~thonkpod@2001:19f0:ac01:b46:5400:1ff:fec7:d73d) (Ping timeout: 240 seconds)
2021-02-22 15:07:53 +0100aggin(~ecm@103.88.87.38) ()
2021-02-22 15:09:25 +0100stree(~stree@68.36.8.116) (Ping timeout: 240 seconds)
2021-02-22 15:09:27 +0100Rudd0(~Rudd0@185.189.115.103) (Ping timeout: 246 seconds)
2021-02-22 15:09:51 +0100thonkpod(~thonkpod@2001:19f0:ac01:b46:5400:1ff:fec7:d73d)
2021-02-22 15:11:19 +0100deviantfero(~deviantfe@190.150.27.58)
2021-02-22 15:11:52 +0100Lowl3v3l(~Lowl3v3l@dslb-002-203-233-121.002.203.pools.vodafone-ip.de)
2021-02-22 15:11:58 +0100 <Martinsos> +merijn yes, it is getting stuck on vim swap files, and we know that is the cause, but it goes beyond that. Anyway, it is good to know in general how to find stack trace for exceptions :D. Anyway, not it works and we figured out where the error is, thanks a lot!
2021-02-22 15:16:29 +0100ystael(~ystael@209.6.50.55) (Read error: Connection reset by peer)
2021-02-22 15:17:30 +0100ep1ctetus(~epictetus@ip72-194-215-136.sb.sd.cox.net)
2021-02-22 15:17:35 +0100 <Martinsos> The problem exactly is: We have our compiler and when in dev mode it watches sourc efiles for changes. First it makes a list of those files and then a little bit later it copies them (for specific reasons), but if some of the files dissapears for some reason (could be caused by editor backup files or smth else), then we get an error. So we are making sure we ignore "does not exist" error in that case, but it was happening on couple of
2021-02-22 15:17:35 +0100 <Martinsos> places in the codebase and we couldn't figure out from error messages where the error is coming from.
2021-02-22 15:20:58 +0100rdivyanshu(uid322626@gateway/web/irccloud.com/x-tworbfpnkgwjjhuq) (Quit: Connection closed for inactivity)
2021-02-22 15:21:20 +0100 <merijn> \o/
2021-02-22 15:21:31 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr)
2021-02-22 15:21:55 +0100stree(~stree@68.36.8.116)
2021-02-22 15:23:09 +0100 <tomsmeding> dminuoso: https://tomsmeding.com/f/thread-stuff-1.eventlog
2021-02-22 15:23:16 +0100ph88(~ph88@ip5f5af71a.dynamic.kabel-deutschland.de) (Ping timeout: 265 seconds)
2021-02-22 15:23:58 +0100 <tomsmeding> dminuoso: that's from this program: https://paste.tomsmeding.com/89q1Gdfk
2021-02-22 15:24:06 +0100 <tomsmeding> (parsecAsync is unused)
2021-02-22 15:24:12 +0100 <tomsmeding> (both exhibit the same issue sometimes)
2021-02-22 15:24:16 +0100conal(~conal@64.71.133.70)
2021-02-22 15:24:53 +0100 <tomsmeding> dminuoso: and what that outputs is here https://paste.tomsmeding.com/7zo6Yish
2021-02-22 15:25:22 +0100 <tomsmeding> might this be a result of the foldl loop never allocating?
2021-02-22 15:28:52 +0100heatsink(~heatsink@2600:1700:bef1:5e10:197a:8f1e:d522:cd3a)
2021-02-22 15:30:25 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta)
2021-02-22 15:31:29 +0100Martinsos(~user@cpe-188-129-56-3.dynamic.amis.hr) (Remote host closed the connection)
2021-02-22 15:31:36 +0100darjeeling_(~darjeelin@122.245.217.214) (Ping timeout: 240 seconds)
2021-02-22 15:33:38 +0100heatsink(~heatsink@2600:1700:bef1:5e10:197a:8f1e:d522:cd3a) (Ping timeout: 264 seconds)
2021-02-22 15:33:56 +0100borne(~fritjof@200116b864cae2007d6d461afdb4e2ff.dip.versatel-1u1.de) (Ping timeout: 240 seconds)
2021-02-22 15:34:54 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 260 seconds)
2021-02-22 15:36:21 +0100kritzefitz(~kritzefit@fw-front.credativ.com) (Ping timeout: 256 seconds)
2021-02-22 15:37:17 +0100raym(~ray@45.64.220.3) (Quit: leaving)
2021-02-22 15:39:36 +0100Stanley00(~stanley00@unaffiliated/stanley00)
2021-02-22 15:40:20 +0100zar(~zar@fw1.ciirc.cvut.cz) (Remote host closed the connection)
2021-02-22 15:40:34 +0100alx741(~alx741@186.178.109.47)
2021-02-22 15:41:04 +0100lawr3nce(~lawr3nce@gateway/tor-sasl/lawr3nce) (Remote host closed the connection)
2021-02-22 15:41:41 +0100zar(~zar@fw1.ciirc.cvut.cz)
2021-02-22 15:42:37 +0100borne(~fritjof@200116b864cae20010f2d07664396fd4.dip.versatel-1u1.de)
2021-02-22 15:42:42 +0100aggin(~ecm@103.88.87.38)
2021-02-22 15:43:45 +0100Stanley00(~stanley00@unaffiliated/stanley00) (Ping timeout: 240 seconds)
2021-02-22 15:46:33 +0100ep1ctetus(~epictetus@ip72-194-215-136.sb.sd.cox.net) (Ping timeout: 246 seconds)
2021-02-22 15:46:45 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Remote host closed the connection)
2021-02-22 15:49:07 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-22 15:49:58 +0100shatriff(~vitaliish@protective.remission.volia.net) (Remote host closed the connection)
2021-02-22 15:50:12 +0100shatriff(~vitaliish@protective.remission.volia.net)
2021-02-22 15:50:32 +0100Sgeo(~Sgeo@ool-18b98aa4.dyn.optonline.net)
2021-02-22 15:52:05 +0100darjeeling_(~darjeelin@122.245.217.214)
2021-02-22 15:52:58 +0100geekosaur(82650c7a@130.101.12.122) (Quit: Connection closed)
2021-02-22 15:54:16 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 15:54:28 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-obkjpkspijblnyqm)
2021-02-22 15:54:41 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 15:55:32 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 15:55:50 +0100shutdown_-h_now(~arjan@2001:1c06:2d0b:2312:b54e:a99d:8dc7:f0b) (Ping timeout: 264 seconds)
2021-02-22 15:56:15 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:15cd:c67f:11dd:b9fc)
2021-02-22 15:56:44 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 15:57:03 +0100kritzefitz(~kritzefit@fw-front.credativ.com)
2021-02-22 15:59:30 +0100nhs(~nhs@c-67-180-177-103.hsd1.ca.comcast.net)
2021-02-22 16:00:16 +0100aggin(~ecm@103.88.87.38) (Quit: WeeChat 3.0.1)
2021-02-22 16:01:24 +0100shutdown_-h_now(~arjan@2001:1c06:2d0b:2312:750e:d23:b28:17e4)
2021-02-22 16:02:32 +0100darjeeling_(~darjeelin@122.245.217.214) (Ping timeout: 272 seconds)
2021-02-22 16:02:32 +0100Guest72364(~textual@zrcout.mskcc.org) (Ping timeout: 272 seconds)
2021-02-22 16:03:10 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2021-02-22 16:03:56 +0100thc202(~thc202@unaffiliated/thc202) (Ping timeout: 240 seconds)
2021-02-22 16:04:10 +0100 <tomsmeding> the problem seems fixed if I use forkOn 🤷
2021-02-22 16:04:24 +0100thc202(~thc202@unaffiliated/thc202)
2021-02-22 16:04:38 +0100Alleria(~textual@mskresolve-a.mskcc.org)
2021-02-22 16:05:02 +0100AlleriaGuest75413
2021-02-22 16:06:00 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:15cd:c67f:11dd:b9fc) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 16:06:31 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net)
2021-02-22 16:06:54 +0100AWizzArd_AWizzArd
2021-02-22 16:06:57 +0100berberman(~berberman@unaffiliated/berberman) (Quit: ZNC 1.8.2 - https://znc.in)
2021-02-22 16:07:10 +0100AWizzArd(~code@gehrels.uberspace.de) (Changing host)
2021-02-22 16:07:10 +0100AWizzArd(~code@unaffiliated/awizzard)
2021-02-22 16:07:23 +0100berberman(~berberman@unaffiliated/berberman)
2021-02-22 16:08:05 +0100 <tomsmeding> (using ghc 8.10.4 instead of 8.8.4 doesn't fix it either)
2021-02-22 16:10:36 +0100aqd(~aqd@84.20.147.33) (Ping timeout: 240 seconds)
2021-02-22 16:12:34 +0100 <tomsmeding> forkOn does _not_ fix my problem, lol
2021-02-22 16:12:55 +0100 <tomsmeding> gotta love this timeline https://tomsmeding.com/ss/get/tomsmeding/V6WqzX
2021-02-22 16:14:10 +0100fendor_(~fendor@178.115.129.208.wireless.dyn.drei.com)
2021-02-22 16:14:22 +0100 <tomsmeding> accompanying eventlog: https://tomsmeding.com/f/thread-stuff-2.eventlog
2021-02-22 16:14:34 +0100 <merijn> tomsmeding: anyway, if this is pure code, shouldn't you be using sparks and parallel strategies, rather than mapConcurrently?
2021-02-22 16:14:55 +0100 <tomsmeding> maybe I should!
2021-02-22 16:15:01 +0100 <merijn> tomsmeding: Hypothesis:
2021-02-22 16:15:21 +0100 <merijn> Your argument to mapConcurrently *does* execute the operation in the thread
2021-02-22 16:15:44 +0100 <merijn> tomsmeding: But! Since mapConcurrently has unbounded parallelism, you create more threads than capabilities
2021-02-22 16:16:12 +0100 <tomsmeding> I'm passing a list of size 3 to mapConcurrently, and my machine has 8 virtual cores, so that "but" is false, I think
2021-02-22 16:16:12 +0100 <merijn> Causing the capability running mapConcurrently to context switch to one of your forked threads from mapConcurrently
2021-02-22 16:16:23 +0100 <tomsmeding> though I am passing -N3 indeed
2021-02-22 16:16:27 +0100 <merijn> tomsmeding: You said you did -N3
2021-02-22 16:16:52 +0100 <merijn> tomsmeding: Haskell code only executes on a capability
2021-02-22 16:17:00 +0100 <tomsmeding> yes sorry I forgot for a moment
2021-02-22 16:17:05 +0100fendor(~fendor@178.165.129.166.wireless.dyn.drei.com) (Ping timeout: 272 seconds)
2021-02-22 16:17:15 +0100 <tomsmeding> so your hypothesis is that the thread running mapConcurrently takes over a capability?
2021-02-22 16:17:50 +0100 <merijn> tomsmeding: My hypothesis is that one of your folds gets scheduled on the mapConcurrently thread, blocking it from spawning more children until another context switch
2021-02-22 16:17:52 +0100 <tomsmeding> then I wonder why the RTS doesn't re-schedule one of the cpu-intensive threads back onto that capability when the initial thread is inevitably done doing stuff
2021-02-22 16:17:55 +0100toorevitimirp(~tooreviti@117.182.181.253) (Remote host closed the connection)
2021-02-22 16:17:57 +0100 <tomsmeding> OH
2021-02-22 16:18:33 +0100 <merijn> tomsmeding: The threading isn't actually pre-emptive, if you never allocate (which might hold for your fold) you get stuck until it's done
2021-02-22 16:19:09 +0100mnrmnaugh(~mnrmnaugh@unaffiliated/mnrmnaugh) (Ping timeout: 264 seconds)
2021-02-22 16:19:09 +0100 <tomsmeding> that is a _very_ likely hypothesis
2021-02-22 16:19:24 +0100hekkaidekapus](~tchouri@gateway/tor-sasl/hekkaidekapus)
2021-02-22 16:20:59 +0100mnrmnaugh(~mnrmnaugh@unaffiliated/mnrmnaugh)
2021-02-22 16:21:12 +0100 <merijn> tomsmeding: I have a bounded mapConcurrently, btw
2021-02-22 16:21:29 +0100 <tomsmeding> I have my own too :p
2021-02-22 16:21:34 +0100 <tomsmeding> but this is a more basic problem
2021-02-22 16:21:34 +0100 <merijn> Then you could ensure you bound yourself to N-1 workers
2021-02-22 16:21:54 +0100 <tomsmeding> makes sense, but then how do I use the full parallelism of my machine? :p
2021-02-22 16:21:59 +0100 <tomsmeding> -N$(ncores+1) ?
2021-02-22 16:22:04 +0100 <tomsmeding> also what are sparks
2021-02-22 16:22:07 +0100 <merijn> tomsmeding: tbh, you don't
2021-02-22 16:22:15 +0100 <tomsmeding> I don't?
2021-02-22 16:22:17 +0100 <merijn> tomsmeding: Dependent on how many cores you have
2021-02-22 16:22:20 +0100 <tomsmeding> 8
2021-02-22 16:22:26 +0100 <merijn> GHC RTS degrades pretty hard above 8
2021-02-22 16:22:48 +0100 <tomsmeding> also if all jobs are independent?
2021-02-22 16:23:05 +0100 <merijn> tomsmeding: You check at runtime how many capabilities you have and spawn that many -1 workers? :p
2021-02-22 16:23:12 +0100darjeeling_(~darjeelin@122.245.217.214)
2021-02-22 16:23:15 +0100 <merijn> tomsmeding: Global GC pause kills you at some point
2021-02-22 16:23:26 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 268 seconds)
2021-02-22 16:23:32 +0100vicfred(~vicfred@unaffiliated/vicfred)
2021-02-22 16:23:37 +0100 <tomsmeding> yes makes sense, but I'd like to be able to run N jobs on a machine with N cores :p
2021-02-22 16:23:59 +0100 <merijn> tomsmeding: then you need to spawn them all first :p
2021-02-22 16:24:37 +0100 <tomsmeding> is that possible (reliably) without -N$(ncores+1)?
2021-02-22 16:25:07 +0100 <merijn> Just make sure they're all suspended until you're done spawning jobs :p
2021-02-22 16:25:37 +0100 <merijn> Can't be done with mapConcurrently as is, though
2021-02-22 16:25:47 +0100 <tomsmeding> I have my own version of mapConcurrently anyway
2021-02-22 16:25:49 +0100 <tomsmeding> but that's a good idea
2021-02-22 16:25:54 +0100 <merijn> tomsmeding: I have something like: https://hackage.haskell.org/package/broadcast-chan-0.2.1.1/docs/BroadcastChan.html#v:parFoldMap
2021-02-22 16:26:20 +0100 <merijn> tomsmeding: Sparks are GHC's mechanism for "pure" parallelism
2021-02-22 16:26:44 +0100 <merijn> @hackage parallel
2021-02-22 16:26:44 +0100 <lambdabot> https://hackage.haskell.org/package/parallel
2021-02-22 16:27:36 +0100 <tomsmeding> can't be done using just base?
2021-02-22 16:28:25 +0100 <merijn> It can, if you reinvent parallel from GHC's primitives :p
2021-02-22 16:28:38 +0100 <tomsmeding> oh so the 'parallel' library implements the stuff using GHC.Conc.par?
2021-02-22 16:28:49 +0100ailrk(~Ailrk@99.199.143.168) ("WeeChat 3.0")
2021-02-22 16:29:17 +0100 <merijn> Yeah
2021-02-22 16:29:24 +0100 <tomsmeding> I see, thanks
2021-02-22 16:29:35 +0100DataComputist(~lumeng@50.43.26.251) (Read error: Connection reset by peer)
2021-02-22 16:29:36 +0100deviantfero(~deviantfe@190.150.27.58) (Ping timeout: 240 seconds)
2021-02-22 16:29:39 +0100 <merijn> Well, and deepseq
2021-02-22 16:29:45 +0100 <tomsmeding> sure
2021-02-22 16:30:10 +0100 <tomsmeding> how do you make sure all worker threads are suspended until all are spawned, by letting them all wait on a BroadcastChan?
2021-02-22 16:30:13 +0100 <tomsmeding> in your lib
2021-02-22 16:30:26 +0100chisui(588298ad@88.130.152.173) (Quit: Connection closed)
2021-02-22 16:30:49 +0100 <merijn> That function doesn't try that, tbh
2021-02-22 16:31:01 +0100 <merijn> Because I made it mostly for IO-bound problems
2021-02-22 16:31:22 +0100Wuzzy(~Wuzzy@p57a2e7e5.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2021-02-22 16:31:23 +0100 <merijn> tomsmeding: So the parallel tasks quickly block and free up a capability
2021-02-22 16:31:28 +0100 <tomsmeding> I see
2021-02-22 16:31:31 +0100perrier-jouet(~perrier-j@modemcable012.251-130-66.mc.videotron.ca) (Quit: WeeChat 3.0)
2021-02-22 16:31:54 +0100 <tomsmeding> would I be able to do it by letting them all do a readMVar before starting compute-intensive work, and doing a put on that MVar when all workers have been spawned?
2021-02-22 16:32:00 +0100 <merijn> tomsmeding: But also, correctly doing mapConcurrently is *hard* and I wouldn't recommend people do it themselves :p
2021-02-22 16:32:04 +0100 <tomsmeding> sparks are probably a better idea, but just for my understanding
2021-02-22 16:32:13 +0100 <merijn> tomsmeding: That was my idea, yeah
2021-02-22 16:32:36 +0100 <tomsmeding> "hard" <- because of exceptions and such?
2021-02-22 16:32:56 +0100 <merijn> tomsmeding: Yes
2021-02-22 16:33:03 +0100 <tomsmeding> yes makes sense
2021-02-22 16:33:15 +0100 <merijn> tomsmeding: Cleanup too
2021-02-22 16:33:36 +0100 <tomsmeding> I wasn't trying to handle exceptions in any kind of graceful way in my code, which is fine for my current purpose
2021-02-22 16:33:38 +0100 <merijn> I like to think I'm fairly good at this stuff, and I *still* got a race condition in my cleanup
2021-02-22 16:33:40 +0100perrier-jouet(~perrier-j@modemcable012.251-130-66.mc.videotron.ca)
2021-02-22 16:33:42 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-22 16:33:43 +0100 <tomsmeding> :p
2021-02-22 16:33:57 +0100 <tomsmeding> I'll certainly try sparks
2021-02-22 16:34:03 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 16:36:29 +0100chisui(588298ad@88.130.152.173)
2021-02-22 16:38:06 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-02-22 16:38:28 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr)
2021-02-22 16:38:36 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 240 seconds)
2021-02-22 16:40:47 +0100acidjnk_new(~acidjnk@p200300d0c739095610730469cbb40c42.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2021-02-22 16:43:28 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta)
2021-02-22 16:46:00 +0100ddellaco_(ddellacost@gateway/vpn/mullvad/ddellacosta)
2021-02-22 16:47:02 +0100chisui(588298ad@88.130.152.173) (Ping timeout: 240 seconds)
2021-02-22 16:48:07 +0100idhugo_(~idhugo@80-62-117-97-mobile.dk.customer.tdc.net)
2021-02-22 16:48:10 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 260 seconds)
2021-02-22 16:49:12 +0100ph88(~ph88@2a01:598:b102:b35c:48a1:e13:f0f:87d6)
2021-02-22 16:49:34 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-22 16:49:49 +0100Guest_88(5619784f@cpc143846-cosh20-2-0-cust78.6-1.cable.virginm.net)
2021-02-22 16:50:38 +0100 <tomsmeding> merijn: this still has suboptimal parallelism: https://paste.tomsmeding.com/YrcNhWBd ; am I doing something wrong?
2021-02-22 16:50:38 +0100idhugo(~idhugo@80-62-117-86-mobile.dk.customer.tdc.net) (Ping timeout: 256 seconds)
2021-02-22 16:51:00 +0100 <tomsmeding> 'parList rseq' and 'parList rpar' give the same results; 'evalList rseq' is nicely sequential as expected
2021-02-22 16:51:32 +0100 <merijn> tomsmeding: Time to dive into the core
2021-02-22 16:51:49 +0100 <merijn> Maybe your computation is getting floated out or something like that :p
2021-02-22 16:51:59 +0100 <tomsmeding> same workload (values1 and values2 have length 3), -N4 -qg -l, threadscope: https://tomsmeding.com/ss/get/tomsmeding/7ajG92
2021-02-22 16:52:12 +0100 <tomsmeding> we need to go deeper
2021-02-22 16:52:32 +0100 <tomsmeding> but... why is it _somewhat_ parallel? I'd understand something can float out and make it all sequential
2021-02-22 16:52:35 +0100 <tomsmeding> but only _some_?
2021-02-22 16:53:15 +0100tomsmedingis very confused by the threadscope diagram just sent because it looks like there are four jobs; there aren't
2021-02-22 16:53:59 +0100ph88(~ph88@2a01:598:b102:b35c:48a1:e13:f0f:87d6) (Read error: Connection reset by peer)
2021-02-22 16:54:15 +0100 <tomsmeding> I fail to see how what I want to do is odd :')
2021-02-22 16:54:31 +0100ericsagn1(~ericsagne@2405:6580:0:5100:d940:32bf:aa80:d462) (Ping timeout: 258 seconds)
2021-02-22 16:54:49 +0100minoru_shiraeesh(~shiraeesh@109.166.57.27)
2021-02-22 16:55:07 +0100 <merijn> tomsmeding: "having N compute heavy jobs on a machine with N cores" is, tbh, rather odd and widely (in HPC and systems circles, anyway) considered a Bad Idea (TM)
2021-02-22 16:55:14 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-egwwbykbvjogeigc)
2021-02-22 16:55:16 +0100 <tomsmeding> is it?
2021-02-22 16:55:27 +0100 <tomsmeding> TIL
2021-02-22 16:55:35 +0100 <merijn> Yes, because you, presumably have system processes running in the background too
2021-02-22 16:55:40 +0100 <tomsmeding> regardless this is with -N4 with 3 jobs :p
2021-02-22 16:55:48 +0100 <tomsmeding> right
2021-02-22 16:56:13 +0100LKoen_(~LKoen@252.248.88.92.rev.sfr.net) (Remote host closed the connection)
2021-02-22 16:58:46 +0100unlink_(~unlink2@p200300ebcf0f8d001f09418ffc2ea630.dip0.t-ipconnect.de)
2021-02-22 16:59:56 +0100unlink2(~unlink2@p200300ebcf241100fcf67590445edc70.dip0.t-ipconnect.de) (Ping timeout: 240 seconds)
2021-02-22 17:00:41 +0100jedws(~jedws@101.184.202.248)
2021-02-22 17:01:06 +0100 <Guest_88> Hi, im trying to get Haskell running on my Mac for the first time. It says ive installed GHC, Cabal and HLS. but when I run `ghci` I don't get anything. It says I need to adjust my path variable but im a complete noob and idrk what im doing. Any help would be appreciated
2021-02-22 17:01:12 +0100fendor_fendor
2021-02-22 17:01:42 +0100 <nshepperd> related to this topic, i just realised that i fudged up -- i have a gui application which spawns a thread to do some heavy processing in the background, and cancels the running thread with killThread when the job is no longer relevant. BUT that background thread itself spawns more threads because it uses 'parallel' to do the work, and those threads don't get killed
2021-02-22 17:02:01 +0100jedws(~jedws@101.184.202.248) (Client Quit)
2021-02-22 17:02:15 +0100 <nshepperd> resulting in regrettable waste of cpu and memory while these zombie threads live out their sentences
2021-02-22 17:02:33 +0100 <tomsmeding> Guest_88: how did you install GHC?
2021-02-22 17:02:50 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:914c:edd0:a91d:47)
2021-02-22 17:03:01 +0100 <tomsmeding> also, what shell are you running? (most likely bash or zsh if you didn't change anything, depending on your macOS version IIRC)
2021-02-22 17:03:07 +0100 <merijn> Guest_88: Did you use ghcup?
2021-02-22 17:03:34 +0100 <Guest_88> I ran the curl function in terminal
2021-02-22 17:03:37 +0100 <merijn> nshepperd: That's why async has link/link2
2021-02-22 17:03:46 +0100 <Guest_88> yes it says ghcup installer
2021-02-22 17:03:49 +0100ariel_(~ariel_@185.163.110.108)
2021-02-22 17:03:53 +0100 <merijn> nshepperd: So you can link child threads to be killed when their parent gets killed
2021-02-22 17:04:06 +0100 <tomsmeding> Guest_88: try opening a new terminal and trying ghci there?
2021-02-22 17:04:09 +0100conal(~conal@64.71.133.70)
2021-02-22 17:04:11 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 17:04:30 +0100 <Guest_88> oh wow
2021-02-22 17:04:41 +0100 <Guest_88> hahahahah, thank you. cannot believe I didn't try that
2021-02-22 17:04:59 +0100 <tomsmeding> ghcup probably changed your .bashrc (initialisation script for your shell), but that does not change the current session
2021-02-22 17:05:09 +0100 <tomsmeding> you have to, well, initialise a new shell to pick up the changes :)
2021-02-22 17:05:11 +0100 <nshepperd> yes. so it seems like i have to use evaluate / mapConcurrently / unsafePerformIO instead of parallel
2021-02-22 17:05:32 +0100 <Guest_88> thanks guys appreciate it a lot:)  can do uni work now
2021-02-22 17:05:38 +0100 <tomsmeding> Guest_88: good luck!
2021-02-22 17:06:35 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:914c:edd0:a91d:47) (Client Quit)
2021-02-22 17:07:09 +0100ericsagn1(~ericsagne@2405:6580:0:5100:e26e:cf9:1dd6:9615)
2021-02-22 17:07:36 +0100da39a3ee5e6b4b0d(~da39a3ee5@2403:6200:8876:b8ec:9dfb:e531:1ee7:9134) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 17:07:56 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr) (Ping timeout: 240 seconds)
2021-02-22 17:08:08 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:914c:edd0:a91d:47)
2021-02-22 17:10:20 +0100unlink2(~unlink2@p200300ebcf0faf0012aa3378b7c33d3b.dip0.t-ipconnect.de)
2021-02-22 17:10:26 +0100 <tomsmeding> merijn: sparks consistently don't work for me; probably doing something wrong but I don't know what
2021-02-22 17:10:48 +0100 <tomsmeding> (don't work = for some reason schedule spark evaluation later than necessary)
2021-02-22 17:10:55 +0100 <merijn> I haven't used them much, tbh
2021-02-22 17:11:07 +0100unlink_(~unlink2@p200300ebcf0f8d001f09418ffc2ea630.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2021-02-22 17:12:17 +0100Rudd0(~Rudd0@185.189.115.103)
2021-02-22 17:13:53 +0100viluon(uid453725@gateway/web/irccloud.com/x-ytvknempinpnbtej) (Quit: Connection closed for inactivity)
2021-02-22 17:17:30 +0100Stanley00(~stanley00@unaffiliated/stanley00)
2021-02-22 17:21:41 +0100aarvar(~foewfoiew@2601:602:a080:fa0:394a:95d6:26a0:dc43)
2021-02-22 17:25:03 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:914c:edd0:a91d:47) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 17:26:57 +0100teardown(~user@gateway/tor-sasl/mrush) (Ping timeout: 268 seconds)
2021-02-22 17:27:26 +0100aveltras(uid364989@gateway/web/irccloud.com/x-uqbohaylhggekrjl)
2021-02-22 17:27:27 +0100chele(~chele@ip5b40237d.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2021-02-22 17:27:42 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net)
2021-02-22 17:30:23 +0100stree(~stree@68.36.8.116) (Ping timeout: 265 seconds)
2021-02-22 17:30:29 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4)
2021-02-22 17:32:06 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 17:32:52 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-02-22 17:33:24 +0100ukari(~ukari@unaffiliated/ukari) (Remote host closed the connection)
2021-02-22 17:33:40 +0100notzmv(~user@unaffiliated/zmv)
2021-02-22 17:33:50 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:914c:edd0:a91d:47)
2021-02-22 17:34:36 +0100ukari(~ukari@unaffiliated/ukari)
2021-02-22 17:34:56 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4) (Ping timeout: 240 seconds)
2021-02-22 17:37:11 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-02-22 17:37:14 +0100DTZUZU_(~DTZUZU@207.81.119.43)
2021-02-22 17:37:54 +0100ph88(~ph88@2a02:8109:9e00:7e5c:b59a:7ec4:364a:86c6)
2021-02-22 17:38:22 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net)
2021-02-22 17:38:28 +0100DTZUZU(~DTZUZU@205.ip-149-56-132.net) (Read error: Connection reset by peer)
2021-02-22 17:39:00 +0100DTZUZU__(~DTZUZU@205.ip-149-56-132.net)
2021-02-22 17:39:41 +0100pja(~phil@2a02:8010:6098:0:f2de:f1ff:fe2c:3d9)
2021-02-22 17:39:46 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de) (Ping timeout: 276 seconds)
2021-02-22 17:40:26 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net)
2021-02-22 17:42:12 +0100DTZUZU_(~DTZUZU@207.81.119.43) (Ping timeout: 256 seconds)
2021-02-22 17:42:14 +0100ClaudiusMaximus(~claude@191.123.199.146.dyn.plus.net)
2021-02-22 17:42:25 +0100ClaudiusMaximus(~claude@191.123.199.146.dyn.plus.net) (Changing host)
2021-02-22 17:42:25 +0100ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus)
2021-02-22 17:42:36 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net) (Ping timeout: 240 seconds)
2021-02-22 17:42:59 +0100stree(~stree@68.36.8.116)
2021-02-22 17:43:35 +0100cfricke(~cfricke@unaffiliated/cfricke) (Ping timeout: 258 seconds)
2021-02-22 17:44:22 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4)
2021-02-22 17:44:44 +0100kritzefitz(~kritzefit@fw-front.credativ.com) (Remote host closed the connection)
2021-02-22 17:45:01 +0100ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus) (Client Quit)
2021-02-22 17:45:56 +0100jakobrs(~user@178.92-220-14.customer.lyse.net)
2021-02-22 17:46:36 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net)
2021-02-22 17:46:41 +0100danza(~francesco@151.53.76.37) (Quit: Leaving)
2021-02-22 17:47:09 +0100pera(~pera@unaffiliated/pera) (Quit: leaving)
2021-02-22 17:47:25 +0100idhugo_(~idhugo@80-62-117-97-mobile.dk.customer.tdc.net) (Ping timeout: 240 seconds)
2021-02-22 17:49:06 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2021-02-22 17:49:37 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl)
2021-02-22 17:49:47 +0100ddellaco_(ddellacost@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 260 seconds)
2021-02-22 17:50:08 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-22 17:50:36 +0100jakobrs(~user@178.92-220-14.customer.lyse.net) (Quit: WeeChat 2.8)
2021-02-22 17:51:22 +0100Guest_88(5619784f@cpc143846-cosh20-2-0-cust78.6-1.cable.virginm.net) (Ping timeout: 240 seconds)
2021-02-22 17:53:45 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl) (Ping timeout: 240 seconds)
2021-02-22 17:54:25 +0100DTZUZU__DTZUZU
2021-02-22 17:54:45 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 240 seconds)
2021-02-22 17:56:34 +0100geekosaur(82650c7a@130.101.12.122)
2021-02-22 17:57:08 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-02-22 17:57:44 +0100conal(~conal@64.71.133.70)
2021-02-22 17:57:54 +0100oisdk(~oisdk@2001:bb6:3329:d100:c73:1525:4623:7479) (Quit: oisdk)
2021-02-22 17:59:03 +0100ep1ctetus(~epictetus@ip72-194-215-136.sb.sd.cox.net)
2021-02-22 18:01:33 +0100frozenErebus(~frozenEre@94.128.219.166)
2021-02-22 18:01:36 +0100cfricke(~cfricke@unaffiliated/cfricke) (Ping timeout: 258 seconds)
2021-02-22 18:02:51 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-22 18:04:50 +0100kritzefitz(~kritzefit@212.86.56.80)
2021-02-22 18:05:54 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net)
2021-02-22 18:09:52 +0100jamm__(~jamm@unaffiliated/jamm)
2021-02-22 18:11:02 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 18:11:59 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 18:12:05 +0100elliott_(~elliott_@pool-108-51-101-42.washdc.fios.verizon.net) (Ping timeout: 240 seconds)
2021-02-22 18:12:24 +0100pera(~pera@unaffiliated/pera)
2021-02-22 18:12:30 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-22 18:12:56 +0100madnificent_(~madnifice@static.210.74.63.178.clients.your-server.de) (Ping timeout: 240 seconds)
2021-02-22 18:12:56 +0100Narinas(~Narinas@189.223.59.23.dsl.dyn.telnor.net)
2021-02-22 18:13:14 +0100jamm_(~jamm@unaffiliated/jamm) (Ping timeout: 264 seconds)
2021-02-22 18:13:22 +0100bitmagie(~Thunderbi@200116b8066311005c3e5c1bf8f86d77.dip.versatel-1u1.de) (Quit: bitmagie)
2021-02-22 18:16:01 +0100rj(~x@gateway/tor-sasl/rj)
2021-02-22 18:17:20 +0100ddellacosta(~ddellacos@86.106.143.124)
2021-02-22 18:19:51 +0100elliott_(~elliott_@pool-108-51-101-42.washdc.fios.verizon.net)
2021-02-22 18:21:36 +0100ddellacosta(~ddellacos@86.106.143.124) (Ping timeout: 246 seconds)
2021-02-22 18:26:34 +0100oisdk(~oisdk@2001:bb6:3329:d100:39a4:c049:dc19:9e44)
2021-02-22 18:28:18 +0100Wuzzy(~Wuzzy@p5790e74a.dip0.t-ipconnect.de)
2021-02-22 18:28:26 +0100kuribas(~user@ptr-25vy0i9qfueg3sz2hh3.18120a2.ip6.access.telenet.be) (Remote host closed the connection)
2021-02-22 18:29:05 +0100rajivr(uid269651@gateway/web/irccloud.com/x-yvjuawdfkidfnsxx) (Quit: Connection closed for inactivity)
2021-02-22 18:29:10 +0100bergey(~user@107.181.19.30)
2021-02-22 18:33:42 +0100geekosaur(82650c7a@130.101.12.122) (Ping timeout: 240 seconds)
2021-02-22 18:35:23 +0100jamm__(~jamm@unaffiliated/jamm) (Remote host closed the connection)
2021-02-22 18:36:46 +0100tomsmedingis afraid I did something wrong https://tomsmeding.com/ss/get/tomsmeding/8eranR
2021-02-22 18:38:07 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-02-22 18:38:30 +0100zebrag(~inkbottle@aaubervilliers-654-1-4-36.w83-200.abo.wanadoo.fr)
2021-02-22 18:42:42 +0100geekosaur(82650c7a@130.101.12.122)
2021-02-22 18:43:14 +0100justanotheruser(~justanoth@unaffiliated/justanotheruser) (Ping timeout: 264 seconds)
2021-02-22 18:43:35 +0100juuandyy(~juuandyy@90.106.228.121)
2021-02-22 18:44:51 +0100chisui(588298ad@88.130.152.173)
2021-02-22 18:46:08 +0100akasha(~user@unaffiliated/akasha)
2021-02-22 18:46:47 +0100augnun(~augnun@2804:14c:658b:41bb:ad14:1908:facd:1e2e)
2021-02-22 18:46:56 +0100borne(~fritjof@200116b864cae20010f2d07664396fd4.dip.versatel-1u1.de) (Ping timeout: 240 seconds)
2021-02-22 18:49:01 +0100ezrakilty(~ezrakilty@97-113-55-149.tukw.qwest.net) (Ping timeout: 256 seconds)
2021-02-22 18:49:56 +0100 <ep1ctetus> Hi, is there a way to do a diff between two records of the same type? To see just which fields have changed
2021-02-22 18:51:34 +0100madnificent(~madnifice@static.210.74.63.178.clients.your-server.de)
2021-02-22 18:51:53 +0100frozenErebus(~frozenEre@94.128.219.166) (Remote host closed the connection)
2021-02-22 18:52:14 +0100 <ep1ctetus> I mean, other than the naive solution in which you diff every field by hand
2021-02-22 18:53:52 +0100 <geekosaur> I don't think so. On some level the runtime knows because unchanged fields should have the same pointers, but that (a) is hidden at the level of Haskell code (b) would still require diffing every field
2021-02-22 18:54:44 +0100Ariakenom(~Ariakenom@2001:9b1:efb:fc00:d46f:450:7429:527)
2021-02-22 18:56:22 +0100 <ep1ctetus> ok
2021-02-22 18:56:28 +0100 <ammar2> if it's just for humans/debugging then a diff of the `show` is probably sufficient
2021-02-22 18:56:47 +0100 <ep1ctetus> ammar2: it is, that's a great idea
2021-02-22 18:57:48 +0100 <swarmcollective> That was my first thought as well, but then I started thinking of the function to line up keys and only showing where values changed, and lengths of lists, and (down the rabbit hole). :)
2021-02-22 18:59:20 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr)
2021-02-22 19:00:15 +0100DataComputist(~lumeng@50.43.26.251)
2021-02-22 19:00:33 +0100epicte7us(~epictetus@ip72-194-215-136.sb.sd.cox.net)
2021-02-22 19:01:09 +0100ixlun(~user@213.205.241.100) (Ping timeout: 264 seconds)
2021-02-22 19:01:20 +0100_xor(~xor@74.215.46.133)
2021-02-22 19:02:42 +0100ukari(~ukari@unaffiliated/ukari) (Remote host closed the connection)
2021-02-22 19:03:11 +0100teardown(~user@gateway/tor-sasl/mrush)
2021-02-22 19:03:24 +0100mrchampion(~mrchampio@38.18.109.23) (Read error: Connection reset by peer)
2021-02-22 19:03:40 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4) (Remote host closed the connection)
2021-02-22 19:03:48 +0100ep1ctetus(~epictetus@ip72-194-215-136.sb.sd.cox.net) (Ping timeout: 256 seconds)
2021-02-22 19:03:54 +0100ukari(~ukari@unaffiliated/ukari)
2021-02-22 19:03:57 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 246 seconds)
2021-02-22 19:06:09 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-22 19:08:01 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-02-22 19:08:23 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 19:08:25 +0100JaakkoLuttinen[m(jluttinema@gateway/shell/matrix.org/x-ijlspogsmepgzkug)
2021-02-22 19:08:47 +0100 <jluttine> Is it so that there's no fold function that could both a) short-circuit and b) recurse into arbitrary depth without stackoverflow? foldr can short-circuit and foldl' can recurse into arbitrary depth, but there's no fold that could achieve both. Or am I missing something?
2021-02-22 19:10:46 +0100 <jluttine> Hmm.. Somehow any and all functions are able to do both (a) and (b) although they are based on foldMap..
2021-02-22 19:10:47 +0100 <glguy> foldr can do both if if you're careful
2021-02-22 19:11:30 +0100mrchampion(~mrchampio@38.18.109.23)
2021-02-22 19:12:24 +0100teardown(~user@gateway/tor-sasl/mrush) (Ping timeout: 268 seconds)
2021-02-22 19:12:42 +0100 <glguy> > let small_sum xs = foldr (\x next acc -> let acc' = x+acc in if acc' > 10 then acc' else next acc') id xs 0 in small_sum [1..]
2021-02-22 19:12:44 +0100 <lambdabot> 15
2021-02-22 19:13:07 +0100justanotheruser(~justanoth@unaffiliated/justanotheruser)
2021-02-22 19:13:16 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-22 19:13:39 +0100C4ladbolg(~darccc-as@ool-18bcd822.dyn.optonline.net)
2021-02-22 19:13:47 +0100 <glguy> for you can foldM with Either to get a short-circuiting "left" fold
2021-02-22 19:14:14 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 19:14:46 +0100smerdyakov99smerdyakov
2021-02-22 19:18:32 +0100teardown(~user@gateway/tor-sasl/mrush)
2021-02-22 19:19:37 +0100 <epicte7us> ammar2: can you recommend a good string diff library? I've been looking around but I haven't found one yet
2021-02-22 19:19:56 +0100juuandyy(~juuandyy@90.106.228.121) (Ping timeout: 240 seconds)
2021-02-22 19:22:33 +0100dyeplexer(~lol@unaffiliated/terpin) (Remote host closed the connection)
2021-02-22 19:24:09 +0100apache8080(~rishi@wsip-70-168-153-252.oc.oc.cox.net)
2021-02-22 19:24:27 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr) (Ping timeout: 265 seconds)
2021-02-22 19:24:33 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-02-22 19:25:32 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta)
2021-02-22 19:25:38 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 19:25:53 +0100deviantfero(~deviantfe@190.150.27.58)
2021-02-22 19:26:08 +0100Tario(~Tario@201.192.165.173) (Read error: Connection reset by peer)
2021-02-22 19:26:43 +0100Tario(~Tario@201.192.165.173)
2021-02-22 19:29:45 +0100juuandyy(~juuandyy@90.106.228.121)
2021-02-22 19:30:26 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 256 seconds)
2021-02-22 19:31:43 +0100C4ladbolg(~darccc-as@ool-18bcd822.dyn.optonline.net) (Quit: C4ladbolg)
2021-02-22 19:32:26 +0100Yumasi(~guillaume@2a01:e0a:5cb:4430:46e1:3435:9ae8:d4e) (Ping timeout: 240 seconds)
2021-02-22 19:32:52 +0100Yumasi(~guillaume@2a01:e0a:5cb:4430:cb25:132:724:97a4)
2021-02-22 19:34:56 +0100notzmv(~user@unaffiliated/zmv)
2021-02-22 19:36:03 +0100Stanley00(~stanley00@unaffiliated/stanley00) ()
2021-02-22 19:36:32 +0100deviantfero(~deviantfe@190.150.27.58) (Ping timeout: 265 seconds)
2021-02-22 19:36:37 +0100 <xsperry> jluttine, you can implement foldl' with foldr
2021-02-22 19:36:55 +0100nrdmn9(~nrdmn@95.129.53.118) (Quit: Ping timeout (120 seconds))
2021-02-22 19:37:12 +0100nrdmn9(~nrdmn@95.129.53.118)
2021-02-22 19:37:23 +0100Franciman(~francesco@host-82-49-79-189.retail.telecomitalia.it) (Quit: Leaving)
2021-02-22 19:37:36 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Remote host closed the connection)
2021-02-22 19:39:57 +0100Franciman(~francesco@host-82-49-79-189.retail.telecomitalia.it)
2021-02-22 19:40:21 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-obkjpkspijblnyqm) (Quit: Connection closed for inactivity)
2021-02-22 19:40:42 +0100geekosaur(82650c7a@130.101.12.122) (Ping timeout: 240 seconds)
2021-02-22 19:42:42 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl)
2021-02-22 19:45:29 +0100ixlun(~user@213.205.241.202)
2021-02-22 19:48:17 +0100 <tomsmeding> can I let my haskell program produce a stack trace upon infinite loop detection?
2021-02-22 19:49:15 +0100kritzefitz(~kritzefit@212.86.56.80) (Ping timeout: 260 seconds)
2021-02-22 19:50:01 +0100 <Ariakenom> tomsmeding: https://downloads.haskell.org/~ghc/8.10.3/docs/html/users_guide/runtime_control.html#rts-flag--xc
2021-02-22 19:50:52 +0100 <tomsmeding> Ariakenom: thank you
2021-02-22 19:51:05 +0100 <tomsmeding> wtf I knew that flag existed, why didn't I find it in the +RTS help output
2021-02-22 19:51:21 +0100stree(~stree@68.36.8.116) (Ping timeout: 256 seconds)
2021-02-22 19:51:21 +0100howdoi(uid224@gateway/web/irccloud.com/x-jhouyavpijlnssvc)
2021-02-22 19:54:09 +0100 <merijn> tomsmeding: Needs a profiling build
2021-02-22 19:54:26 +0100 <merijn> tomsmeding: Not sure if it shows up in the help of the profling build, but that might be it
2021-02-22 19:54:26 +0100 <tomsmeding> I was running a profiling build, that's the sad part
2021-02-22 19:54:34 +0100 <tomsmeding> it does :p
2021-02-22 19:54:46 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-22 19:54:54 +0100 <sm[m]> epic fail tomsmeding :)
2021-02-22 19:55:06 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 19:55:07 +0100 <tomsmeding> \o\
2021-02-22 19:55:13 +0100 <merijn> Wise man Merijn says: Everyone should make it a point to browse/skim throught eh GHC User Guide at least once a year
2021-02-22 19:55:28 +0100 <tomsmeding> today's chapter: RTS options
2021-02-22 19:55:44 +0100terrorjack(~terrorjac@ec2-52-47-143-92.eu-west-3.compute.amazonaws.com) (Quit: The Lounge - https://thelounge.chat)
2021-02-22 19:55:56 +0100 <tomsmeding> I made my program a number of times faster today by using -A512M
2021-02-22 19:55:58 +0100 <merijn> Although it may be bit presumptious to call myself wise...
2021-02-22 19:56:04 +0100 <merijn> Wise people don't do phds >.>
2021-02-22 19:56:15 +0100 <tomsmeding> says he to #haskell
2021-02-22 19:56:24 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de)
2021-02-22 19:56:29 +0100 <merijn> Everyone who has a phd knows it >.>
2021-02-22 19:56:48 +0100 <merijn> Reactions to the statement "I have a PhD":
2021-02-22 19:56:52 +0100ddellacosta(~ddellacos@86.106.143.215)
2021-02-22 19:56:57 +0100 <merijn> Normal people: "Wow, you must be so smart!"
2021-02-22 19:57:09 +0100 <merijn> Academics: "Wow...so you're dumb and stubborn too, huh?"
2021-02-22 19:57:34 +0100terrorjack(~terrorjac@ec2-52-47-143-92.eu-west-3.compute.amazonaws.com)
2021-02-22 19:57:39 +0100 <tomsmeding> then again, most academics have a phd, so you can bounce that back to them
2021-02-22 19:57:46 +0100 <merijn> sure
2021-02-22 19:57:50 +0100 <tomsmeding> :)
2021-02-22 19:58:01 +0100 <merijn> It's not an insult, it's an observation of fact >.>
2021-02-22 19:58:38 +0100geekosaur(82650c7a@130.101.12.122)
2021-02-22 19:59:51 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 256 seconds)
2021-02-22 20:01:12 +0100Mrbuck(~Mrbuck@gateway/tor-sasl/mrbuck)
2021-02-22 20:01:16 +0100ddellacosta(~ddellacos@86.106.143.215) (Ping timeout: 240 seconds)
2021-02-22 20:03:34 +0100berberman_(~berberman@unaffiliated/berberman)
2021-02-22 20:03:43 +0100berberman(~berberman@unaffiliated/berberman) (Ping timeout: 272 seconds)
2021-02-22 20:04:14 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4)
2021-02-22 20:04:21 +0100stree(~stree@68.36.8.116)
2021-02-22 20:04:22 +0100chisui(588298ad@88.130.152.173) (Ping timeout: 240 seconds)
2021-02-22 20:04:52 +0100Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi)
2021-02-22 20:05:34 +0100ajkskdkf(50bdd4b7@183.212.189.80.dyn.plus.net)
2021-02-22 20:06:49 +0100chisui(588298ad@88.130.152.173)
2021-02-22 20:07:43 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4) (Remote host closed the connection)
2021-02-22 20:07:59 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4)
2021-02-22 20:09:42 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-22 20:11:33 +0100carlomagno(~cararell@148.87.23.11)
2021-02-22 20:14:18 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Ping timeout: 246 seconds)
2021-02-22 20:17:50 +0100ddellacosta(~ddellacos@86.106.143.150)
2021-02-22 20:17:56 +0100juuandyy(~juuandyy@90.106.228.121) (Ping timeout: 240 seconds)
2021-02-22 20:19:42 +0100Pickchea(~private@unaffiliated/pickchea)
2021-02-22 20:20:59 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de) (Ping timeout: 260 seconds)
2021-02-22 20:22:34 +0100ddellacosta(~ddellacos@86.106.143.150) (Ping timeout: 256 seconds)
2021-02-22 20:23:21 +0100gioyik(~gioyik@gateway/tor-sasl/gioyik)
2021-02-22 20:24:12 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-22 20:26:55 +0100frozenErebus(~frozenEre@94.128.219.166)
2021-02-22 20:27:02 +0100aveltras(uid364989@gateway/web/irccloud.com/x-uqbohaylhggekrjl) (Quit: Connection closed for inactivity)
2021-02-22 20:27:05 +0100hseg(~gesh@IGLD-84-228-239-97.inter.net.il)
2021-02-22 20:27:13 +0100pavonia^\_^\(~user@unaffiliated/siracusa)
2021-02-22 20:27:16 +0100frozenErebus(~frozenEre@94.128.219.166) (Client Quit)
2021-02-22 20:28:42 +0100frozenErebus(~frozenEre@94.128.219.166)
2021-02-22 20:29:55 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 20:30:10 +0100 <hseg> consider zeroSums in http://ix.io/2QoS Morally speaking, given [s], (s->Int), I should be able to obtain a function [s] -> [[s]] that uses the _shape_ of zeroSums on the input
2021-02-22 20:30:40 +0100 <hseg> and clearly, if I generalize zeroSums a bit and futz with newtypes + custom instances I can make it work
2021-02-22 20:30:50 +0100 <hseg> is there a simpler way of doing this?
2021-02-22 20:31:16 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-22 20:33:08 +0100 <hseg> (e.g. for \c -> ord 'm' - ord c :: Char -> Int, I should have zeroSums' "kojp" = ["ko","jp"])
2021-02-22 20:33:39 +0100 <hseg> bc zeroSums [2,-2,3,-3] = [[2,-2],[3,-3]]
2021-02-22 20:35:01 +0100ajkskdkf(50bdd4b7@183.212.189.80.dyn.plus.net) (Quit: Connection closed)
2021-02-22 20:35:53 +0100jamm_(~jamm@unaffiliated/jamm)
2021-02-22 20:36:46 +0100Nahra(~Nahra@unaffiliated/nahra)
2021-02-22 20:36:52 +0100nbloomf_(~nbloomf@2600:1700:ad14:3020:a8e7:6389:162:dcda)
2021-02-22 20:37:29 +0100 <hseg> ... just realized I'm asking why the *On family of variants can't be made into combinators
2021-02-22 20:37:41 +0100conal(~conal@64.71.133.70)
2021-02-22 20:39:25 +0100 <hseg> ... in fact, As from iso-deriving might very well be abused in this direction
2021-02-22 20:39:55 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:914c:edd0:a91d:47) (Ping timeout: 258 seconds)
2021-02-22 20:39:56 +0100jamm_(~jamm@unaffiliated/jamm) (Ping timeout: 240 seconds)
2021-02-22 20:40:24 +0100 <hseg> (esp if one reinterprets the api as providing retraction-deriving)
2021-02-22 20:41:27 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4) (Remote host closed the connection)
2021-02-22 20:43:56 +0100 <tomsmeding> hseg: zeroSums [2,-2,3,-3] = [[2,0],[3,0]]
2021-02-22 20:44:19 +0100hsegfacepalms
2021-02-22 20:44:21 +0100 <hseg> y
2021-02-22 20:44:25 +0100 <hseg> intention remains
2021-02-22 20:46:09 +0100kam1(~kam1@113.203.63.236)
2021-02-22 20:47:31 +0100 <hseg> i.e. want some automagic way of converting f :: [a] -> []^n a and p :: (s
2021-02-22 20:47:35 +0100 <hseg> oops
2021-02-22 20:48:17 +0100 <hseg> basically, it seems I want the function given by the free theorem of [a] -> [[a]]
2021-02-22 20:48:38 +0100hololeap_(~hololeap@unaffiliated/hololeap)
2021-02-22 20:48:57 +0100 <hseg> hrm. i'm not making any sense
2021-02-22 20:49:11 +0100 <tomsmeding> hseg: https://paste.tomsmeding.com/f01NDZG6 ?
2021-02-22 20:49:26 +0100timCF(~i.tkachuk@m91-129-99-43.cust.tele2.ee)
2021-02-22 20:49:37 +0100 <tomsmeding> (produces ["ko","jp"])
2021-02-22 20:49:53 +0100evandocarmo(~evandocar@047-014-000-054.res.spectrum.com)
2021-02-22 20:50:06 +0100 <tomsmeding> not saying it's elegant or anything :p
2021-02-22 20:50:07 +0100 <hseg> ok, nice
2021-02-22 20:50:11 +0100 <timCF> q
2021-02-22 20:50:22 +0100zariuq(~zar@fw1.ciirc.cvut.cz)
2021-02-22 20:50:23 +0100 <tomsmeding> sometimes direct recursion works fine
2021-02-22 20:50:33 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-22 20:50:34 +0100 <timCF> sorry, wrong buffer
2021-02-22 20:50:55 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 20:50:59 +0100 <tomsmeding> timCF: be happy it was just 'q'
2021-02-22 20:51:10 +0100hololeap_(~hololeap@unaffiliated/hololeap) (Read error: Connection reset by peer)
2021-02-22 20:51:26 +0100hololeap(~hololeap@unaffiliated/hololeap) (Ping timeout: 240 seconds)
2021-02-22 20:51:33 +0100 <evandocarmo> Hi! I installed ghcup on wsl2 but I'm getting this error when trying to compile a hello world file
2021-02-22 20:51:43 +0100 <evandocarmo> /usr/bin/ld.gold: error: cannot find -lgmp
2021-02-22 20:51:44 +0100 <evandocarmo> collect2: error: ld returned 1 exit status
2021-02-22 20:51:46 +0100 <evandocarmo> `gcc' failed in phase `Linker'. (Exit code: 1)yes
2021-02-22 20:51:47 +0100 <hseg> what i'm saying is basically: given f :: [a] -> [[a]], we have a free theorem that for p :: s -> a, we have (map.map) p . f = f . map p
2021-02-22 20:52:36 +0100leo__(~leo@cpc96810-rdng27-2-0-cust409.15-3.cable.virginm.net) (Ping timeout: 256 seconds)
2021-02-22 20:52:40 +0100 <hseg> i'd like to pretend (map.map) p has an inverse
2021-02-22 20:52:48 +0100zar(~zar@fw1.ciirc.cvut.cz) (Ping timeout: 246 seconds)
2021-02-22 20:52:56 +0100 <hseg> and construct f' = ((map.map) p)^-1 . f . map p
2021-02-22 20:53:14 +0100 <maerwald> evandocarmo: you need: build-essential curl libffi-dev libffi6 libgmp-dev libgmp10 libncurses-dev libncurses5 libtinfo5
2021-02-22 20:53:41 +0100hololeap_(~hololeap@unaffiliated/hololeap)
2021-02-22 20:53:53 +0100zargoertzel(~zar@fw1.ciirc.cvut.cz)
2021-02-22 20:53:55 +0100 <hseg> which should work when applied to chunk
2021-02-22 20:54:23 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-22 20:55:16 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 240 seconds)
2021-02-22 20:55:54 +0100 <tomsmeding> hseg: how is ((map.map) p)^-1 different from (map.map) p^-1 ?
2021-02-22 20:56:14 +0100 <hseg> now, what I *can* do is generalize zeroSums to (Eq a, Monoid a), and (ab)use iso-deriving's types to get the instances using the projection
2021-02-22 20:56:33 +0100conal(~conal@64.71.133.70)
2021-02-22 20:56:34 +0100zariuq(~zar@fw1.ciirc.cvut.cz) (Ping timeout: 256 seconds)
2021-02-22 20:56:43 +0100 <hseg> tomsmeding: not different, just follows from the equation more immediately
2021-02-22 20:57:44 +0100 <tomsmeding> but if p^-1 exists, then '(map.map) p^-1 . f . map p' is a fine haskell expression :p
2021-02-22 20:58:24 +0100 <hseg> :D as i said, i want to pretend (map.map) p is invertible. which means i'm pretending p is invertible
2021-02-22 20:58:26 +0100 <hseg> it isn't
2021-02-22 20:58:48 +0100 <hseg> which is why i need to do the entire information hiding rigamarole
2021-02-22 21:00:51 +0100 <evandocarmo> @maerwald thanks, that did it
2021-02-22 21:00:51 +0100 <lambdabot> Unknown command, try @list
2021-02-22 21:01:11 +0100evandocarmo(~evandocar@047-014-000-054.res.spectrum.com) (Quit: WeeChat 2.8)
2021-02-22 21:03:24 +0100rayyyy(~nanoz@gateway/tor-sasl/nanoz) (Ping timeout: 268 seconds)
2021-02-22 21:05:35 +0100petersen(~petersen@redhat/juhp) (Ping timeout: 256 seconds)
2021-02-22 21:07:56 +0100petersen(~petersen@redhat/juhp)
2021-02-22 21:10:08 +0100ClaudiusMaximus(~claude@191.123.199.146.dyn.plus.net)
2021-02-22 21:10:08 +0100ClaudiusMaximus(~claude@191.123.199.146.dyn.plus.net) (Changing host)
2021-02-22 21:10:08 +0100ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus)
2021-02-22 21:10:31 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-02-22 21:14:20 +0100__minoru__shirae(~shiraeesh@77.94.25.80)
2021-02-22 21:14:39 +0100minoru_shiraeesh(~shiraeesh@109.166.57.27) (Ping timeout: 256 seconds)
2021-02-22 21:14:58 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 21:20:50 +0100 <koz_> jared-w: I remember you told me of a way to dodge Hackage's nagging about -Werror by specifying it in cabal.project instead of the Cabal file. How do you do this again?
2021-02-22 21:21:17 +0100xelxebar(~xelxebar@gateway/tor-sasl/xelxebar) (Ping timeout: 268 seconds)
2021-02-22 21:21:40 +0100xelxebar(~xelxebar@gateway/tor-sasl/xelxebar)
2021-02-22 21:22:34 +0100 <merijn> koz_: "package foo\n ghc-options: -Werror"
2021-02-22 21:22:43 +0100 <koz_> merijn: Thank you!
2021-02-22 21:22:45 +0100pera(~pera@unaffiliated/pera) (Quit: leaving)
2021-02-22 21:22:55 +0100 <merijn> koz_: https://github.com/merijn/Belewitte/blob/master/cabal.project.ghc-8.10#L9
2021-02-22 21:23:34 +0100 <merijn> koz_: You can, essentially, specify arbitrary overrides for almost anything in cabal.project
2021-02-22 21:24:03 +0100hamid(~hamid@unaffiliated/hamid)
2021-02-22 21:24:35 +0100 <koz_> merijn: I'm aware that this is possible, I've just never had to do it.
2021-02-22 21:24:51 +0100evandocarmo(~evandocar@047-014-000-054.res.spectrum.com)
2021-02-22 21:25:09 +0100 <evandocarmo> Now running into errors with the language server on vscode =/
2021-02-22 21:25:16 +0100 <evandocarmo> It's installed and in path on wsl2
2021-02-22 21:25:31 +0100 <evandocarmo> but using vscode remote wsl it crashes and throws this error:
2021-02-22 21:25:39 +0100 <evandocarmo> Cannot find any haskell-language-server exe, looked for: haskell-language-server-8.10.4, haskell-language-server-8.10, haskell-language-server
2021-02-22 21:25:59 +0100 <swarmcollective> Is HLS for 8.10.4 released yet?
2021-02-22 21:26:27 +0100 <swarmcollective> Then again, it says it is searching for 8.10 as well.
2021-02-22 21:26:51 +0100Aquazi(uid312403@gateway/web/irccloud.com/x-foyzutngnaknewjf)
2021-02-22 21:27:43 +0100 <geekosaur> but as iit uses ghc-api, there's no "generic works with any 8.10", it's specific to the compiler version
2021-02-22 21:28:11 +0100 <monochrom> "8.10" may mean "8.10.<known latest>"
2021-02-22 21:28:44 +0100 <monochrom> to be sure, another possibility is "8.10.<the one you installed and I can find>"
2021-02-22 21:29:22 +0100 <swarmcollective> evandocarmo, if you are ok with running the Haskell tooling from a container (source code kept on wsl2 or Windows drive), you might want to consider using a .devcontainer with the official Haskell docker image (where the tools are already setup).
2021-02-22 21:30:06 +0100 <monochrom> Wait, there is an official Haskell docker image?
2021-02-22 21:30:19 +0100 <merijn> monochrom: Define "official" :p
2021-02-22 21:30:22 +0100boxscape(86ab2c66@gateway/web/cgi-irc/kiwiirc.com/ip.134.171.44.102)
2021-02-22 21:30:25 +0100 <swarmcollective> Yes, I use it in the .devcontainer, though it can be used directly as desired.
2021-02-22 21:30:42 +0100 <merijn> monochrom: Did you know no one can stop you from naming things whatever you want online? :D
2021-02-22 21:30:43 +0100 <swarmcollective> Ok, I almost put "official", but it says it is published by Haskell. :)
2021-02-22 21:31:07 +0100 <monochrom> Is it somewhere on https://www.haskell.org/downloads/ ?
2021-02-22 21:31:39 +0100 <swarmcollective> "haskell
2021-02-22 21:31:50 +0100 <swarmcollective> Docker Official Images
2021-02-22 21:31:52 +0100 <swarmcollective> Haskell is an advanced purely-functional programming language.y
2021-02-22 21:32:01 +0100 <swarmcollective> https://hub.docker.com/_/haskell
2021-02-22 21:32:34 +0100 <monochrom> OK thanks.
2021-02-22 21:33:05 +0100 <monochrom> But merijn's point must be taken into account.
2021-02-22 21:33:06 +0100 <evandocarmo> containers sound fun
2021-02-22 21:33:14 +0100 <evandocarmo> but it'd be nice to get a simpler set up working first
2021-02-22 21:33:18 +0100 <swarmcollective> The .devcontainer is fairly easy to setup, but I have a pre-built one if you want a drop in.
2021-02-22 21:33:41 +0100 <evandocarmo> Sure! I can give it a try
2021-02-22 21:33:43 +0100 <monochrom> I will tell you a true story that strikes fear into your heart.
2021-02-22 21:33:59 +0100 <evandocarmo> lol
2021-02-22 21:34:00 +0100 <swarmcollective> evandocarmo, the only reason I mention it is because you said you are using wsl2 (which is running a container)
2021-02-22 21:34:06 +0100 <evandocarmo> true
2021-02-22 21:34:09 +0100 <merijn> monochrom: It links to a repo under the haskell github organisation, I have to say I don't recognise most of the names listed as contributor, but phadej is on there, so it's probably semi-legit
2021-02-22 21:34:33 +0100 <merijn> monochrom: Is it about tenure tracks? Because if not, I doubt it can scare me :p
2021-02-22 21:34:36 +0100 <monochrom> It begins with a trivial (or trick) question on an exam. "What is the probability that a circle has a corner?"
2021-02-22 21:35:11 +0100 <merijn> Actually, there's really only one thing that strikes fear into my heart
2021-02-22 21:35:22 +0100 <monochrom> A lot of students were really tripped by that question and answered "1/2 because maybe it has a corner maybe not".
2021-02-22 21:35:53 +0100 <monochrom> So a TA decided to troll the students.
2021-02-22 21:36:38 +0100 <dolio> They don't know that 3/4 of naturally occurring circles have corners?
2021-02-22 21:36:43 +0100 <monochrom> The TA uploaded a Python library to the common Python library repo. It claims to calculate the probabilities of various shapes having corners. It gives the answer 1/2 for circles.
2021-02-22 21:37:03 +0100acidjnk_new(~acidjnk@p200300d0c7390990100579feb774bab7.dip0.t-ipconnect.de)
2021-02-22 21:37:25 +0100 <hseg> reminiscent of my hs math teacher's "isocles circle"
2021-02-22 21:37:30 +0100 <monochrom> So now we can all refer students to a Python script that depends on that "official" library that says the answer is 1/2.
2021-02-22 21:37:46 +0100 <hseg> (prob was a slip of a tongue, still hilarious)
2021-02-22 21:38:07 +0100 <swarmcollective> I was once asked to fill out a self-assessment where one of the questions was "Always tell the truth?" and the responses where "1 = needs improvement, 2 = meets expectation, or 3 = exceeds expectation"
2021-02-22 21:38:14 +0100 <hseg> rofl. and the students started doubting themselves?
2021-02-22 21:38:16 +0100 <swarmcollective> How can you exceed the expectation there?
2021-02-22 21:38:21 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Ping timeout: 264 seconds)
2021-02-22 21:38:27 +0100 <koala_man> lol what
2021-02-22 21:38:28 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4)
2021-02-22 21:38:36 +0100 <hseg> by extending time beyond this universe?
2021-02-22 21:38:36 +0100 <EvanR> circles are the epitome of cornerlessness
2021-02-22 21:38:38 +0100 <monochrom> More seriously, https://frasertweedale.github.io/blog-fp/posts/2021-02-12-haskell-dependency-confusion.html
2021-02-22 21:38:39 +0100 <merijn> swarmcollective: I always exceed my expectations
2021-02-22 21:38:59 +0100 <monochrom> Be careful with what "official" files you trust.
2021-02-22 21:39:09 +0100 <merijn> swarmcollective: Because anything besides curling up and crying in bed with the cat counts as "exceeding my expectations"
2021-02-22 21:39:16 +0100 <dolio> swarmcollective: You must not have watched much House M.D.
2021-02-22 21:39:47 +0100 <merijn> monochrom: The only story that strikes fear in my heart is "despite have 6 backups, geographically distributed and some in the cloud, all copies of your thesis draft have been deleted" >.>
2021-02-22 21:40:11 +0100 <monochrom> swarmcollective: I think I exceed the expectation. I tell truths even when other people consider it rude to tell those truths. Does that count? >:)
2021-02-22 21:40:13 +0100 <koala_man> monochrom: do you tell students about this? what's their reaction?
2021-02-22 21:40:40 +0100 <swarmcollective> monochrom, Ha! That's a good one.
2021-02-22 21:41:08 +0100 <swarmcollective> merijn, gotta start somewhere!
2021-02-22 21:41:21 +0100 <hseg> merijn: please spare my heart
2021-02-22 21:41:31 +0100 <hseg> that thought keeps me up at night
2021-02-22 21:41:57 +0100nut(~user@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2021-02-22 21:42:04 +0100ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus) (Quit: ->)
2021-02-22 21:42:16 +0100 <merijn> hseg: It doesn't keep me up, but if there's *any* event in the universe that might make me snap and murder someone, it's gotta be a high contender :p
2021-02-22 21:42:37 +0100 <swarmcollective> Still, though, how do you "exceed the expectation" when the expectation is "Always ..."
2021-02-22 21:43:06 +0100styledash(~styledash@157.230.173.136) (Quit: The Lounge - https://thelounge.chat)
2021-02-22 21:43:21 +0100 <monochrom> What if you always tells truths, and sometimes also tell lies in conjunction to truths?
2021-02-22 21:43:47 +0100styledash(~styledash@157.230.173.136)
2021-02-22 21:44:43 +0100 <swarmcollective> Probability of encountering a circle with at least one corner... that reminds me of the word problem: If driving from point A to point B takes 60 minutes at 60 units per hour, and you drive half way from point A to point B at 30 units per hour, how fast do you have to drive to still reach point B in 60 minutes?"
2021-02-22 21:44:50 +0100 <monochrom> What if you take "absurd :: Void -> a" seriously? If you always says "contradiction" then you are always telling the truth, but you also exceed that. >:)
2021-02-22 21:45:46 +0100 <monochrom> "godspeed"
2021-02-22 21:46:00 +0100 <evandocarmo> ok I think I know what my problem is
2021-02-22 21:46:03 +0100 <swarmcollective> :D
2021-02-22 21:46:04 +0100 <evandocarmo> ghc is version 8.10.4
2021-02-22 21:46:17 +0100 <evandocarmo> but hls higher version seems to be 8.10.3?
2021-02-22 21:46:40 +0100 <merijn> evandocarmo: That sounds likely
2021-02-22 21:46:43 +0100 <swarmcollective> Right, I didn't think it was released yet.
2021-02-22 21:47:00 +0100 <monochrom> 8.10.4 is kind of days-new, not even 1 week.
2021-02-22 21:47:01 +0100 <swarmcollective> but things change all the time. :)
2021-02-22 21:47:16 +0100 <evandocarmo> hm
2021-02-22 21:47:21 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 264 seconds)
2021-02-22 21:47:34 +0100 <evandocarmo> so I guess I should probably be using cabal or stack instead of fighting version issues by myself?
2021-02-22 21:47:37 +0100 <evandocarmo> is that what they're for?
2021-02-22 21:48:10 +0100 <monochrom> I don't think anything eliminates fighting version issues.
2021-02-22 21:48:41 +0100 <monochrom> Unless you include "don't use certain software".
2021-02-22 21:48:52 +0100 <geekosaur> s/certain/any/
2021-02-22 21:49:18 +0100 <merijn> evandocarmo: haskell-language-server uses GHC as library and therefore expects to be the exact same version as the GHC you use
2021-02-22 21:49:39 +0100 <merijn> evandocarmo: 8.10.4 is fairly new (last week?) so there's no haskell-language-server release for it yet
2021-02-22 21:49:51 +0100 <merijn> Simple solution would be "downgrade to 8.10.3 if possible"
2021-02-22 21:49:52 +0100 <evandocarmo> ok, so I'd need to downgrade my ghc
2021-02-22 21:49:57 +0100 <evandocarmo> cool
2021-02-22 21:50:13 +0100 <merijn> Well, that or "wait a week or so"
2021-02-22 21:50:29 +0100 <monochrom> 8.10.4 fixes some Windows issues, so I sympathize if it is a hard requirement.
2021-02-22 21:50:59 +0100 <merijn> Another problem easily solved by lowering expectations! \o/
2021-02-22 21:51:34 +0100 <monochrom> stack eliminates version issues by what I said. stackage does not give you certain libraries.
2021-02-22 21:51:54 +0100 <monochrom> walled gardens gotta wall.
2021-02-22 21:52:10 +0100son0p(~son0p@181.136.122.143) (Quit: leaving)
2021-02-22 21:52:13 +0100 <evandocarmo> I'm using wsl2 so I don't think Windows should be an issue?
2021-02-22 21:52:29 +0100 <evandocarmo> This is literally my first day trying to learn haskell so bear with me
2021-02-22 21:52:30 +0100 <monochrom> Right, you're good.
2021-02-22 21:52:31 +0100 <merijn> evandocarmo: Instead you get exciting *different* issues! :D
2021-02-22 21:52:38 +0100 <merijn> (maybe)
2021-02-22 21:53:02 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr)
2021-02-22 21:53:25 +0100 <merijn> To be fair, the windows fix for 8.10.4 is...rather niche and unlikely to affect beginners :p
2021-02-22 21:53:41 +0100 <monochrom> that too
2021-02-22 21:53:55 +0100nut(~user@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Remote host closed the connection)
2021-02-22 21:54:32 +0100 <monochrom> Wait, no, you never know how high "beginners" aim, all this "dive-in project" fads and all...
2021-02-22 21:55:06 +0100 <merijn> monochrom: Well, it requires specific bug in the dynamic loading of code :p
2021-02-22 21:55:18 +0100 <monochrom> You don't know that the average beginner doesn't start right away with a "highly concurrent highly parallelized web app" that runs into the known issues.
2021-02-22 21:55:19 +0100 <geekosaur> murphy says they'll hit it right away just because
2021-02-22 21:55:20 +0100pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net) (Quit: gone to sleep. ZZZzzz…)
2021-02-22 21:55:42 +0100 <merijn> geekosaur: tbh, if you're dynamically loading code that's on you :p
2021-02-22 21:55:50 +0100 <merijn> #NoSympathy
2021-02-22 21:57:08 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-02-22 21:58:38 +0100evandocarmo(~evandocar@047-014-000-054.res.spectrum.com) (Ping timeout: 265 seconds)
2021-02-22 21:58:50 +0100xff0x(~xff0x@2001:1a81:52fd:ec00:624b:a459:3f1:35ff) (Ping timeout: 264 seconds)
2021-02-22 21:58:51 +0100ddellacosta(~ddellacos@86.106.143.124)
2021-02-22 21:59:15 +0100xff0x(~xff0x@2001:1a81:52fd:ec00:e0fa:9c50:8b73:f75c)
2021-02-22 22:00:08 +0100styledash(~styledash@157.230.173.136) (Quit: The Lounge - https://thelounge.chat)
2021-02-22 22:00:28 +0100styledash(~styledash@157.230.173.136)
2021-02-22 22:01:22 +0100 <monochrom> Does HLS load code dynamically?
2021-02-22 22:01:47 +0100apache8080(~rishi@wsip-70-168-153-252.oc.oc.cox.net) (Ping timeout: 260 seconds)
2021-02-22 22:03:46 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 22:03:50 +0100Mrbuck(~Mrbuck@gateway/tor-sasl/mrbuck) (Ping timeout: 268 seconds)
2021-02-22 22:04:11 +0100_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-02-22 22:04:20 +0100 <geekosaur> it compiles; if that compilation includes TH which loads another module, that can be "yes"
2021-02-22 22:05:25 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2021-02-22 22:05:33 +0100 <geekosaur> whether that's enough by itself to trigger the problem is another question, given "highly concurrent highly parallelized" which neither ghc nor ghc-lib is particularly
2021-02-22 22:05:49 +0100 <monochrom> heh OK
2021-02-22 22:08:01 +0100Neuromancer(~Neuromanc@unaffiliated/neuromancer) (Quit: Going offline, see ya! (www.adiirc.com))
2021-02-22 22:08:37 +0100Neuromancer(~Neuromanc@unaffiliated/neuromancer)
2021-02-22 22:09:03 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 256 seconds)
2021-02-22 22:09:31 +0100Neuromancer(~Neuromanc@unaffiliated/neuromancer) (Read error: Connection reset by peer)
2021-02-22 22:10:01 +0100apache8080(~rishi@wsip-70-168-153-252.oc.oc.cox.net)
2021-02-22 22:10:12 +0100Neuromancer(~Neuromanc@unaffiliated/neuromancer)
2021-02-22 22:11:27 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-22 22:12:05 +0100stree(~stree@68.36.8.116) (Ping timeout: 240 seconds)
2021-02-22 22:14:13 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2021-02-22 22:16:23 +0100borne(~fritjof@200116b864cae20010f2d07664396fd4.dip.versatel-1u1.de)
2021-02-22 22:16:32 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 22:17:37 +0100Pickchea(~private@unaffiliated/pickchea) (Quit: Leaving)
2021-02-22 22:21:25 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2021-02-22 22:22:09 +0100oisdk(~oisdk@2001:bb6:3329:d100:39a4:c049:dc19:9e44) (Quit: oisdk)
2021-02-22 22:23:56 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-22 22:24:46 +0100stree(~stree@68.36.8.116)
2021-02-22 22:26:00 +0100zmagii(~zmagii@unaffiliated/zmagii)
2021-02-22 22:27:02 +0100ddellacosta(~ddellacos@86.106.143.124) (Remote host closed the connection)
2021-02-22 22:27:47 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4) (Remote host closed the connection)
2021-02-22 22:29:28 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de)
2021-02-22 22:31:56 +0100hamid(~hamid@unaffiliated/hamid) (Ping timeout: 240 seconds)
2021-02-22 22:34:50 +0100carlomagno(~cararell@148.87.23.11) (Remote host closed the connection)
2021-02-22 22:35:05 +0100carlomagno(~cararell@148.87.23.11)
2021-02-22 22:38:45 +0100ddellacosta(~ddellacos@86.106.143.85)
2021-02-22 22:38:46 +0100augnun(~augnun@2804:14c:658b:41bb:ad14:1908:facd:1e2e) (Remote host closed the connection)
2021-02-22 22:39:05 +0100augnun(~augnun@2804:14c:658b:41bb:437a:74a3:dd59:93bd)
2021-02-22 22:39:08 +0100conal(~conal@64.71.133.70)
2021-02-22 22:39:09 +0100gadtrider(~gadtrider@dvc-186-186-101-190.movil.vtr.net)
2021-02-22 22:39:15 +0100shatriff(~vitaliish@protective.remission.volia.net) (Remote host closed the connection)
2021-02-22 22:39:29 +0100usr25(~usr25@unaffiliated/usr25)
2021-02-22 22:39:32 +0100ddellacosta(~ddellacos@86.106.143.85) (Remote host closed the connection)
2021-02-22 22:39:46 +0100gadtrider(~gadtrider@dvc-186-186-101-190.movil.vtr.net) (Remote host closed the connection)
2021-02-22 22:39:50 +0100shatriff(~vitaliish@protective.remission.volia.net)
2021-02-22 22:40:52 +0100slack1256(~slack1256@dvc-186-186-101-190.movil.vtr.net)
2021-02-22 22:42:57 +0100geekosaur(82650c7a@130.101.12.122) (Quit: Connection closed)
2021-02-22 22:43:24 +0100conal(~conal@64.71.133.70) (Ping timeout: 246 seconds)
2021-02-22 22:45:19 +0100redcherri(bab702ef@186.183.2.239)
2021-02-22 22:46:07 +0100alx741(~alx741@186.178.109.47) (Ping timeout: 260 seconds)
2021-02-22 22:47:20 +0100evandocarmo(~evandocar@047-014-000-054.res.spectrum.com)
2021-02-22 22:47:36 +0100 <evandocarmo> Is there a clear winner between cabal and stack?
2021-02-22 22:49:04 +0100 <swarmcollective> "It depends"
2021-02-22 22:49:15 +0100 <evandocarmo> of course, haha
2021-02-22 22:49:48 +0100 <swarmcollective> That would be based on your use case. I believe they try to solve the same problem in different ways.
2021-02-22 22:50:21 +0100hamid(~hamid@unaffiliated/hamid)
2021-02-22 22:50:30 +0100 <evandocarmo> Ok, I guess I'll stick with cabal for now? seems simple enough
2021-02-22 22:50:40 +0100 <evandocarmo> I want to build a simple url shortener as a learning project
2021-02-22 22:51:01 +0100 <sclv> if you want to use some bleeding edge things like backpack, cabal has more support and stack has fallen behind. otherwise its taste and preference
2021-02-22 22:51:03 +0100 <swarmcollective> Cabal, if I understand correctly, tries to calculate the set of libraries (versions) that work for your configuration. Stack tries to provide a cohesive set of libraries that have been tested to work together, but limits the total number of libraries to keep complexity within their ability to maintain.
2021-02-22 22:51:28 +0100 <evandocarmo> I see
2021-02-22 22:51:42 +0100 <evandocarmo> So stack is almost like a framework of sorts?
2021-02-22 22:51:52 +0100 <evandocarmo> In the sense that they curate the available packages etc
2021-02-22 22:52:23 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 22:53:13 +0100redcherri(bab702ef@186.183.2.239) ()
2021-02-22 22:53:26 +0100 <koz_> :k ReaderT
2021-02-22 22:53:27 +0100 <lambdabot> * -> (* -> *) -> * -> *
2021-02-22 22:53:32 +0100 <koz_> :k MaybeT
2021-02-22 22:53:33 +0100 <lambdabot> error:
2021-02-22 22:53:33 +0100 <lambdabot> Not in scope: type constructor or class ‘MaybeT’
2021-02-22 22:53:33 +0100 <lambdabot> Perhaps you meant ‘Maybe’ (imported from Data.Maybe)
2021-02-22 22:53:55 +0100 <koz_> I guess that should have been '(Type -> Type) -> Type -> Type'?
2021-02-22 22:54:10 +0100 <slack1256> I think lambdabot is on a old ghc version
2021-02-22 22:54:25 +0100hamid(~hamid@unaffiliated/hamid) (Ping timeout: 240 seconds)
2021-02-22 22:54:25 +0100 <koz_> slack1256: Oh yeah, this is modulo * vs Type.
2021-02-22 22:55:09 +0100 <slack1256> I just remember the rename of * (star) to `Type`. Now with levity polymorphism I am lost again heh.
2021-02-22 22:55:27 +0100 <ephemient> IMO: Stack is convenient if you are developing an end application and don't care availability of latest or uncommon libraries, it insulates you from having to deal with changing version bounds - at a cost, of course. if you're building a library for others to consume or making use of newer features, libraries, etc. then Cabal would fit better. (but that's just my opinion)
2021-02-22 22:56:17 +0100deviantfero(~deviantfe@190.150.27.58)
2021-02-22 22:57:05 +0100dhouthoo(~dhouthoo@ptr-eitgbj2w0uu6delkbrh.18120a2.ip6.access.telenet.be) (Quit: WeeChat 3.0)
2021-02-22 22:57:33 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 264 seconds)
2021-02-22 22:57:47 +0100boxscape71(86ab2c66@gateway/web/cgi-irc/kiwiirc.com/ip.134.171.44.102)
2021-02-22 22:58:03 +0100_bo(~bo@178.150.122.153) (Read error: Connection reset by peer)
2021-02-22 23:00:16 +0100boxscape(86ab2c66@gateway/web/cgi-irc/kiwiirc.com/ip.134.171.44.102) (Ping timeout: 240 seconds)
2021-02-22 23:00:50 +0100alx741(~alx741@186.178.108.179)
2021-02-22 23:00:52 +0100 <shapr> also, the latest stack versions have a bug where dependencies are often recompiled even when not changed
2021-02-22 23:03:05 +0100ddellacosta(~ddellacos@86.106.143.189)
2021-02-22 23:05:15 +0100 <monochrom> Well, cabal and stack take turns to have that kind of bugs, so meh.
2021-02-22 23:06:26 +0100slack1256never used stack until yesterday for a yesod page. Not so bad.
2021-02-22 23:07:06 +0100 <monochrom> That one is bound to work excellently because they are from the same company.
2021-02-22 23:07:17 +0100 <__minoru__shirae> evandocarmo: "So stack is almost like a framework of sorts?" I think the word "registry" is more... how do you say it? - to the point.
2021-02-22 23:07:35 +0100ddellacosta(~ddellacos@86.106.143.189) (Ping timeout: 260 seconds)
2021-02-22 23:07:58 +0100 <monochrom> Stackage would be that registry. stack is the program.
2021-02-22 23:08:07 +0100perrier-jouet(~perrier-j@modemcable012.251-130-66.mc.videotron.ca) (Quit: WeeChat 3.0)
2021-02-22 23:08:11 +0100oisdk(~oisdk@2001:bb6:3329:d100:39a4:c049:dc19:9e44)
2021-02-22 23:08:21 +0100 <monochrom> Neither is a framework. At least not my understanding.
2021-02-22 23:08:40 +0100 <monochrom> Now, yesod, that counts as a framework.
2021-02-22 23:08:41 +0100cafce25(~cafce25@ipbcc3009d.dynamic.kabel-deutschland.de)
2021-02-22 23:12:26 +0100nbloomf_(~nbloomf@2600:1700:ad14:3020:a8e7:6389:162:dcda) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-22 23:12:38 +0100 <slack1256> Yeah, but it is a *web* framework. `stack` and `cabal` are other kinds of programs.
2021-02-22 23:13:32 +0100crobbins(~crobbins@2600:1700:48eb:8490:51aa:2f5f:ac36:490b)
2021-02-22 23:14:13 +0100 <slack1256> It is funny, back in the day yesod was described as being `rails but with haskell`. Now `ihp` is `rails on haskell` and yesod is a not-that-opiniated framework.
2021-02-22 23:15:11 +0100 <__minoru__shirae> they still generate html markup?
2021-02-22 23:15:42 +0100 <slack1256> yesod uses shakesperean templates (hamlet, lucius, julius), yes.
2021-02-22 23:15:55 +0100 <Clint> so are you saying that ihp is good or bad?
2021-02-22 23:16:10 +0100 <__minoru__shirae> I thought that generating markup became old, everybody moved to rest-services.
2021-02-22 23:16:30 +0100 <slack1256> __minoru__shirae: people use scotty or servant for that.
2021-02-22 23:16:33 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4)
2021-02-22 23:16:48 +0100polyrain(~polyrain@2001:8003:e4d8:4101:d50e:d40d:4648:6ec)
2021-02-22 23:17:06 +0100hseg(~gesh@IGLD-84-228-239-97.inter.net.il) (Ping timeout: 256 seconds)
2021-02-22 23:19:05 +0100 <slack1256> Clint: neither, I am just re-expressing a view found in HN and twitter https://twitter.com/mattoflambda/status/1275469470559907840 .
2021-02-22 23:21:46 +0100ph88^(~ph88@2a02:8109:9e00:7e5c:c0c2:6fb4:8104:9592)
2021-02-22 23:23:36 +0100Nahra(~Nahra@unaffiliated/nahra) (Quit: leaving)
2021-02-22 23:24:12 +0100mirrorbird(~psutcliff@2a00:801:446:6dfc:fadb:e310:6ed2:16d)
2021-02-22 23:25:31 +0100ph88(~ph88@2a02:8109:9e00:7e5c:b59a:7ec4:364a:86c6) (Ping timeout: 258 seconds)
2021-02-22 23:27:33 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-tytajkaqktamnirt)
2021-02-22 23:29:03 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Ping timeout: 260 seconds)
2021-02-22 23:29:40 +0100heatsink(~heatsink@2600:1700:bef1:5e10:5cae:3825:c434:6c4) (Remote host closed the connection)
2021-02-22 23:33:09 +0100Varis(~Tadas@unaffiliated/varis) (Remote host closed the connection)
2021-02-22 23:34:12 +0100Franciman(~francesco@host-82-49-79-189.retail.telecomitalia.it) (Quit: Leaving)
2021-02-22 23:34:51 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-22 23:34:57 +0100borne(~fritjof@200116b864cae20010f2d07664396fd4.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2021-02-22 23:36:21 +0100 <shapr> I gotta try ihp at some point, it looks neat
2021-02-22 23:37:09 +0100xff0x(~xff0x@2001:1a81:52fd:ec00:e0fa:9c50:8b73:f75c) (Ping timeout: 272 seconds)
2021-02-22 23:37:30 +0100xff0x(~xff0x@2001:1a81:52fd:ec00:adc0:d786:7e02:e1ee)
2021-02-22 23:39:23 +0100joecordingley(~joecordin@2a01:4b00:868e:6b00:318a:1414:2e62:d4a0)
2021-02-22 23:39:45 +0100xcmw(~textual@dyn-72-33-2-47.uwnet.wisc.edu)
2021-02-22 23:40:03 +0100borne(~fritjof@200116b864cae20010f2d07664396fd4.dip.versatel-1u1.de)
2021-02-22 23:40:37 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-22 23:40:57 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-22 23:42:00 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-22 23:44:14 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta)
2021-02-22 23:48:27 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-02-22 23:48:50 +0100ddellacosta(ddellacost@gateway/vpn/mullvad/ddellacosta) (Ping timeout: 256 seconds)
2021-02-22 23:50:44 +0100jajdkfjsksla(50bdd4b7@183.212.189.80.dyn.plus.net)
2021-02-22 23:53:22 +0100cheater(~user@unaffiliated/cheater) (Ping timeout: 256 seconds)
2021-02-22 23:55:31 +0100danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa) (Ping timeout: 272 seconds)
2021-02-22 23:57:24 +0100cheater(~user@unaffiliated/cheater)
2021-02-22 23:57:49 +0100oisdk(~oisdk@2001:bb6:3329:d100:39a4:c049:dc19:9e44) (Quit: oisdk)
2021-02-22 23:57:56 +0100notzmv(~user@unaffiliated/zmv) (Remote host closed the connection)
2021-02-22 23:58:45 +0100notzmv(~user@unaffiliated/zmv)
2021-02-22 23:58:53 +0100oisdk(~oisdk@2001:bb6:3329:d100:39a4:c049:dc19:9e44)
2021-02-22 23:59:33 +0100deviantfero(~deviantfe@190.150.27.58) (Ping timeout: 256 seconds)