IRCBrowse

2021/02/03

2021-02-03 00:00:14 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 00:00:23 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-03 00:00:25 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 256 seconds)
2021-02-03 00:01:32 +0100Ariakenom(~Ariakenom@2001:9b1:efb:fc00:41bc:5f34:8ff6:3878) (Quit: Leaving)
2021-02-03 00:01:55 +0100carlomagno(~cararell@148.87.23.7) (Quit: Leaving.)
2021-02-03 00:02:12 +0100frdg(~nick@pool-96-252-123-136.bstnma.fios.verizon.net) (Read error: Connection reset by peer)
2021-02-03 00:02:35 +0100frdg(~user@pool-96-252-123-136.bstnma.fios.verizon.net)
2021-02-03 00:04:20 +0100 <frdg> I am not understanding the behavior of manyTill. For example I would like to parse `123` out of `foo bar 123 baz` by saying `skip everything until I can parse an integer and then parse the integer`. http://dpaste.com/7RFE5D26G
2021-02-03 00:05:04 +0100carlomagno(~cararell@148.87.23.7)
2021-02-03 00:06:50 +0100geyaeb(~geyaeb@gateway/tor-sasl/geyaeb)
2021-02-03 00:08:06 +0100 <Axman6> My guess is the first P.integer is consuming the integer it parses
2021-02-03 00:08:51 +0100 <frdg> hmm maybe because P.anyChar matches 123?
2021-02-03 00:08:58 +0100 <Axman6> manyTill is usually used for things like lists, so you'd have char '[' *> manyTill item (char ']')
2021-02-03 00:09:25 +0100 <Axman6> no, manyTill doesn;t reset to the point where the terminating parser begins
2021-02-03 00:09:25 +0100 <koz_> Are there block comments in Cabal file syntax?
2021-02-03 00:09:37 +0100ubert(~Thunderbi@p200300ecdf25d920e6b318fffe838f33.dip0.t-ipconnect.de) (Ping timeout: 260 seconds)
2021-02-03 00:10:03 +0100 <Axman6> so yuo get "foo bar " consumed by the repeated anyChar, and then the "!23" is consumed by the P.integer
2021-02-03 00:10:23 +0100 <Axman6> koz_: yep, I believe they;re the same as Haskell comments? At least -- works IIRC
2021-02-03 00:10:28 +0100heatsink(~heatsink@2600:1700:bef1:5e10:d018:6f9c:3910:36c8)
2021-02-03 00:11:05 +0100 <Axman6> frdg: so manyTill anyChar integer consumes "foo bar 123"
2021-02-03 00:11:32 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 00:11:37 +0100 <frdg> ok I am trying something
2021-02-03 00:11:58 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 00:12:23 +0100 <Axman6> looks like you really need something like manyTillWith :: PArser a -> Parser b -> Parser ([a], b)
2021-02-03 00:14:17 +0100knupfer(~Thunderbi@200116b82c1c27005d8bb76cf3d58ad1.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2021-02-03 00:15:02 +0100heatsink(~heatsink@2600:1700:bef1:5e10:d018:6f9c:3910:36c8) (Ping timeout: 264 seconds)
2021-02-03 00:16:09 +0100mrchampion(~mrchampio@38.18.109.23) (Ping timeout: 264 seconds)
2021-02-03 00:16:20 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-03 00:17:21 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 264 seconds)
2021-02-03 00:17:34 +0100 <frdg> Axman6: I understand the behavior now thanks
2021-02-03 00:18:14 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net) (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”)
2021-02-03 00:19:02 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 00:19:03 +0100 <koz_> It seems to be 'nope'.
2021-02-03 00:19:06 +0100mrchampion(~mrchampio@38.18.109.23)
2021-02-03 00:19:20 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 00:19:37 +0100 <monochrom> parsec's manyTill example is manyTill anyChar (try (string "-->")) and explains why the try.
2021-02-03 00:20:56 +0100 <ph88> can i query which functions and types are used in a module ?
2021-02-03 00:21:33 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 264 seconds)
2021-02-03 00:21:35 +0100alx741(~alx741@181.196.69.29) (Quit: alx741)
2021-02-03 00:22:01 +0100 <monochrom> ghc -ddump-minimal-imports may help
2021-02-03 00:22:20 +0100 <Axman6> koz_: oh, I missed the word "block" in your messsage, sorry
2021-02-03 00:23:25 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh) (Quit: Leaving)
2021-02-03 00:24:16 +0100 <ph88> monochrom, does that calculate the imports or the actual usage of said imports ?
2021-02-03 00:25:05 +0100 <Axman6> HLS will tell you if you have excess imports, and can make your imports more specific
2021-02-03 00:26:08 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Remote host closed the connection)
2021-02-03 00:27:23 +0100frdg(~user@pool-96-252-123-136.bstnma.fios.verizon.net) ("ERC (IRC client for Emacs 27.1)")
2021-02-03 00:27:40 +0100 <koz_> Or hlint if you don't want something that heavy.
2021-02-03 00:27:43 +0100 <monochrom> If you import something and end up not using it, it doesn't show up in -ddump-minimal-imports
2021-02-03 00:27:54 +0100 <koz_> I think there's also a GHC warning for it?
2021-02-03 00:28:22 +0100 <monochrom> If you import a whole module of 1000 functions and end up using just one, you get "import M(f)" telling you you're only using f.
2021-02-03 00:28:51 +0100 <monochrom> This is why it helps identifying what you actually use.
2021-02-03 00:28:56 +0100 <Axman6> on this topic, there is also weeder, which can tell you wqhich _exports_ from a module aren't used
2021-02-03 00:31:17 +0100heatsink(~heatsink@2600:1700:bef1:5e10:d018:6f9c:3910:36c8)
2021-02-03 00:31:53 +0100 <koz_> Axman6: Why did I have a hurr-hurr moment when I saw 'weeder' as a title?
2021-02-03 00:32:17 +0100 <koz_> *hits bong* "Yeah man, you don't need those exports."
2021-02-03 00:32:19 +0100aidecoe(~aidecoe@unaffiliated/aidecoe) (Remote host closed the connection)
2021-02-03 00:33:03 +0100haskell-noob(2ea162a3@46.161.98.163) (Quit: Ping timeout (120 seconds))
2021-02-03 00:33:21 +0100aidecoe(~aidecoe@unaffiliated/aidecoe)
2021-02-03 00:33:56 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-03 00:35:21 +0100nuncanada(~dude@179.235.160.168) (Ping timeout: 264 seconds)
2021-02-03 00:36:10 +0100revprez_anzio(~revprez_a@pool-108-49-213-40.bstnma.fios.verizon.net) (Quit: leaving)
2021-02-03 00:37:10 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-03 00:41:58 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 00:42:53 +0100matijja(~matijja@193.77.181.208) (Ping timeout: 260 seconds)
2021-02-03 00:43:37 +0100matijja(~matijja@193.77.181.208)
2021-02-03 00:44:24 +0100desophos(~desophos@2601:249:1680:a570:a1da:e51c:3dc0:1f5c)
2021-02-03 00:44:47 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-vebmjsskufunaflq)
2021-02-03 00:44:56 +0100mmohammadi9812(~mmohammad@2.178.211.91) (Ping timeout: 240 seconds)
2021-02-03 00:46:48 +0100 <Axman6> ehhhhhh
2021-02-03 00:46:56 +0100 <Axman6> blaze it bro
2021-02-03 00:47:08 +0100 <Axman6> (where it is dead code)
2021-02-03 00:47:15 +0100 <koz_> Lol, blaze is also a Haskell package...
2021-02-03 00:47:33 +0100 <koz_> You see a build-depends with like, all the blaze packages and weeder.
2021-02-03 00:47:36 +0100 <koz_> :D
2021-02-03 00:47:36 +0100 <Axman6> ha, damn I'm sad I missed thay joke
2021-02-03 00:47:39 +0100 <Axman6> that*
2021-02-03 00:47:55 +0100mmohammadi9812(~mmohammad@2.178.169.112)
2021-02-03 00:48:48 +0100 <aldum> /l
2021-02-03 00:49:28 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-03 00:52:43 +0100 <dexterfoo> how do i write a function that appends a single element to the end of a list and get NonEmpty? append :: [a] -> a -> NonEmpty a
2021-02-03 00:54:01 +0100 <Axman6> that sounds not particularly difficult, have you tried to write it?
2021-02-03 00:54:32 +0100 <Axman6> append :: [a] -> a -> NonEmpty a; append xs a = case xs of ...
2021-02-03 00:55:12 +0100 <Axman6> what do you need to return if xs is []? what do you need to do if xs is (y:ys)?
2021-02-03 00:55:42 +0100 <dexterfoo> i'm wondering if there is a built in function
2021-02-03 00:55:45 +0100 <Axman6> you know in both cases that you need to return something :| someList
2021-02-03 00:56:10 +0100 <Axman6> well, you could just use xs <> singleton a
2021-02-03 00:56:36 +0100geowiesnot(~user@87-89-181-157.abo.bbox.fr)
2021-02-03 00:56:55 +0100obihann(~jhann@142.177.168.17) (Ping timeout: 258 seconds)
2021-02-03 00:56:56 +0100mbomba(~mbomba@bras-base-toroon2719w-grc-53-142-114-5-26.dsl.bell.ca) (Quit: WeeChat 3.0)
2021-02-03 00:57:00 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 246 seconds)
2021-02-03 00:57:18 +0100deviantfero(~deviantfe@190.150.27.58) (Ping timeout: 258 seconds)
2021-02-03 00:57:59 +0100frdg(~user@pool-96-252-123-136.bstnma.fios.verizon.net)
2021-02-03 00:58:45 +0100deviantfero(~deviantfe@190.150.27.58)
2021-02-03 01:00:05 +0100jpds_jpds
2021-02-03 01:00:23 +0100 <frdg> Why do I get different behavior from parsing `P.string "foo"` and `P.char '\t'` in these examples? I would expect parser1 to fail and parser2 to succeed but the opposite is true. http://dpaste.com/27YKB62DA
2021-02-03 01:01:53 +0100bitmagie(~Thunderbi@200116b806d5dd009974a509bc35d318.dip.versatel-1u1.de)
2021-02-03 01:02:17 +0100 <monochrom> P.integer skips trailing whitespace?
2021-02-03 01:02:35 +0100 <monochrom> I would think this would be in the doc?
2021-02-03 01:03:01 +0100 <monochrom> No, let me correct that wording.
2021-02-03 01:03:09 +0100 <monochrom> I swear I saw it said in the doc.
2021-02-03 01:03:23 +0100 <frdg> ok now I see what is happening
2021-02-03 01:05:00 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-03 01:05:34 +0100Dykam(Dykam@dykam.nl)
2021-02-03 01:05:41 +0100feliocrat(~feliocrat@31.223.8.190) (Remote host closed the connection)
2021-02-03 01:05:54 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-03 01:06:31 +0100comboy(~quassel@tesuji.pl)
2021-02-03 01:06:36 +0100conal(~conal@64.71.133.70)
2021-02-03 01:08:30 +0100bitmagie(~Thunderbi@200116b806d5dd009974a509bc35d318.dip.versatel-1u1.de) (Quit: bitmagie)
2021-02-03 01:09:26 +0100charukiewicz(~quassel@irouteince04.i.subnet.rcn.com)
2021-02-03 01:09:57 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Ping timeout: 258 seconds)
2021-02-03 01:10:37 +0100frdg(~user@pool-96-252-123-136.bstnma.fios.verizon.net) ("ERC (IRC client for Emacs 27.1)")
2021-02-03 01:11:13 +0100comboy_(~quassel@tesuji.pl) (*.net *.split)
2021-02-03 01:11:13 +0100Dykam_(Dykam@dykam.nl) (*.net *.split)
2021-02-03 01:11:34 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-03 01:11:55 +0100bennofs_(~quassel@dslb-094-222-055-031.094.222.pools.vodafone-ip.de)
2021-02-03 01:12:06 +0100 <desophos> hi, i'm using Gen for randomization and i want to perform weighted random selection. Gen has a function `frequency :: [(Int, Gen a)] -> Gen a`, but i have `Gen [a]` because i use Gen's `vectorOf :: Int -> Gen a -> Gen [a]`. i can make `Gen [(Int, a)]` but i'm not sure what to do from there. is the solution simply to write my own variant of `frequency`? am i allowed to just copy the source of `frequency` and change bind to
2021-02-03 01:12:07 +0100 <desophos> fmap? thanks :)
2021-02-03 01:15:12 +0100alx741(~alx741@181.196.69.29)
2021-02-03 01:15:30 +0100olligobber(olligobber@gateway/vpn/privateinternetaccess/olligobber)
2021-02-03 01:15:33 +0100bennofs__(~quassel@dslb-094-222-058-083.094.222.pools.vodafone-ip.de) (Ping timeout: 246 seconds)
2021-02-03 01:15:45 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Ping timeout: 240 seconds)
2021-02-03 01:23:05 +0100Tario(~Tario@200.119.184.36) (Read error: Connection reset by peer)
2021-02-03 01:23:46 +0100Tario(~Tario@201.192.165.173)
2021-02-03 01:23:57 +0100DirefulSalt(DirefulSal@gateway/vpn/privateinternetaccess/direfulsalt) (Remote host closed the connection)
2021-02-03 01:28:51 +0100Tops2(~Tobias@dyndsl-095-033-022-141.ewe-ip-backbone.de)
2021-02-03 01:29:39 +0100 <Axman6> Gen is a monad right?
2021-02-03 01:29:45 +0100 <desophos> yes it is
2021-02-03 01:30:17 +0100 <Axman6> so if you can produce the vector of values you want, and a vecvtor of equal length of weights that you want, then you can just use frequency (zip prequencies values)
2021-02-03 01:31:04 +0100 <desophos> but `vectorOf` returns `Gen [a]`, not `[Gen a]`
2021-02-03 01:32:26 +0100 <Axman6> weighted n = vectorOf n arbitrary >>= \frequencies -> vectorOf n arbitrary >>= \values -> frequency (zip frequencies (map pure values)) -- this type checks but I'm not sure if it's what you want
2021-02-03 01:32:52 +0100 <Axman6> what do you want the Gen a passed to frequency to produce?
2021-02-03 01:33:00 +0100Cale(~cale@cpef48e38ee8583-cm0c473de9d680.cpe.net.cable.rogers.com)
2021-02-03 01:33:19 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-03 01:33:34 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Remote host closed the connection)
2021-02-03 01:35:05 +0100 <desophos> well, it should just produce an a? i tried mapping pure but i couldn't get it to work
2021-02-03 01:35:25 +0100 <desophos> so maybe that was just my error
2021-02-03 01:35:29 +0100 <ph88> I have an expression tree that is a functor, first i was thinking to map over it .. then i thought i need to carry some state around. "problem" is that fold gives me back the state i want to carry and not the original structure. Is there another function i can use ?
2021-02-03 01:36:06 +0100 <Axman6> :t mapAccumL
2021-02-03 01:36:07 +0100 <lambdabot> Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
2021-02-03 01:36:16 +0100 <Axman6> maybe?
2021-02-03 01:36:18 +0100 <ph88> is there a monadic version of that ?
2021-02-03 01:36:40 +0100 <Axman6> you might just be able to use traverse
2021-02-03 01:36:51 +0100 <Axman6> but you question isn't clear enough to tell exactly what you need
2021-02-03 01:37:17 +0100 <ph88> i don't know how to put my question clearer
2021-02-03 01:37:36 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 01:37:53 +0100 <desophos> ah, i wasn't mapping pure because i have a function that builds each (Int, a) pair. i can make it generate an [Int] based on my [a] instead
2021-02-03 01:38:13 +0100 <ph88> mapM :: Monad m => (a -> m b) -> t a -> m (t b) i need to map every element but just have state while mapping ..
2021-02-03 01:38:42 +0100 <Cale> This is somewhat offtopic, but does anyone know whether anyone in the cubical type theory world ever succeeded in computing Brunerie's number? I recall hearing that the computation was taking over 90 hours and 1TB of memory, but I don't know if it ever finished, or if they just gave up.
2021-02-03 01:39:01 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 256 seconds)
2021-02-03 01:39:23 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Client Quit)
2021-02-03 01:39:27 +0100 <desophos> thanks Axman6, i'll try that
2021-02-03 01:40:59 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 01:41:15 +0100 <Axman6> ph88: well.. whatb about the State monad :)
2021-02-03 01:41:16 +0100Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi) (Quit: Leaving.)
2021-02-03 01:41:57 +0100geowiesnot(~user@87-89-181-157.abo.bbox.fr) (Ping timeout: 264 seconds)
2021-02-03 01:42:03 +0100 <ph88> Cale, looks like it has not been found
2021-02-03 01:42:08 +0100 <ph88> Axman6, ye that might work
2021-02-03 01:42:22 +0100bitmagie(~Thunderbi@200116b806d5dd009974a509bc35d318.dip.versatel-1u1.de)
2021-02-03 01:42:30 +0100 <Cale> Of course, it's known to actually be 2, lol
2021-02-03 01:42:48 +0100 <Cale> The most expensive 2 in the world
2021-02-03 01:43:22 +0100ph88^(~ph88@ip5f5af71a.dynamic.kabel-deutschland.de)
2021-02-03 01:43:50 +0100 <monochrom> 2 is special in many ways, I'm OK with 2 being expensive.
2021-02-03 01:46:28 +0100 <ph88^> Cale, how is that known ?
2021-02-03 01:46:49 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 01:47:22 +0100zebrag(~inkbottle@aaubervilliers-654-1-80-120.w86-212.abo.wanadoo.fr) (Quit: Konversation terminated!)
2021-02-03 01:47:25 +0100ph88(~ph88@2a02:8109:9e00:7e5c:7043:c8b:15ab:5d6e) (Ping timeout: 272 seconds)
2021-02-03 01:47:40 +0100zebrag(~inkbottle@aaubervilliers-654-1-80-120.w86-212.abo.wanadoo.fr)
2021-02-03 01:47:57 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Quit: mputz)
2021-02-03 01:49:19 +0100 <Cale> ph88^: Both by proving it directly in HoTT, and it's also a classical result of homotopy theory
2021-02-03 01:50:05 +0100 <dolio> Cale: It hasn't been calculated, but people think that the expense might not be essential, but an artifact of how naive all the implementations are.
2021-02-03 01:50:20 +0100 <monochrom> :)
2021-02-03 01:50:43 +0100 <monochrom> Theorem: Every number can be made as expensive as you like. :)
2021-02-03 01:51:23 +0100bitmapper(uid464869@gateway/web/irccloud.com/x-zkobjotekrfpnlhu) (Quit: Connection closed for inactivity)
2021-02-03 01:55:08 +0100rajivr(uid269651@gateway/web/irccloud.com/x-njsalrgkfquqyrca)
2021-02-03 01:55:19 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-02-03 01:56:18 +0100 <monochrom> On the flip side, if you try to describe a difficult problem but screws up the wording, you end up stating a O(1)-time problem.
2021-02-03 01:57:16 +0100 <monochrom> For example, Bill Gates's book screws up saying "public key encryption relies on hard problems such as prime factorization" by wording "factoring primes".
2021-02-03 01:57:26 +0100tsrt^(tsrt@ip98-184-89-2.mc.at.cox.net) ()
2021-02-03 01:57:49 +0100 <monochrom> (I suspect that Bill Gates didn't make that mistake, an editor (obviously math-blind English major right?) did.)
2021-02-03 02:03:08 +0100elliott__(~elliott@pool-108-51-101-42.washdc.fios.verizon.net)
2021-02-03 02:06:13 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Ping timeout: 256 seconds)
2021-02-03 02:08:21 +0100justsomeguy(~justsomeg@unaffiliated/--/x-3805311)
2021-02-03 02:09:35 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-03 02:09:40 +0100metreo(~Thunderbi@unaffiliated/metreo) (Quit: metreo)
2021-02-03 02:10:32 +0100bitmagie(~Thunderbi@200116b806d5dd009974a509bc35d318.dip.versatel-1u1.de) (Quit: bitmagie)
2021-02-03 02:10:59 +0100whataday(~xxx@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2021-02-03 02:11:52 +0100LiyangHU[m](liyangmatr@gateway/shell/matrix.org/x-khsquopybxsinqvm)
2021-02-03 02:12:06 +0100whataday(~xxx@2400:8902::f03c:92ff:fe60:98d8)
2021-02-03 02:16:45 +0100thefybe(~thefybe@249-147-161-N2.customer.vsm.sh) (Ping timeout: 264 seconds)
2021-02-03 02:24:25 +0100boxscape(4ff0baf3@gateway/web/cgi-irc/kiwiirc.com/ip.79.240.186.243) (Quit: Connection closed)
2021-02-03 02:26:37 +0100ph88^(~ph88@ip5f5af71a.dynamic.kabel-deutschland.de) (Ping timeout: 258 seconds)
2021-02-03 02:27:51 +0100charukiewicz(~quassel@irouteince04.i.subnet.rcn.com) (Quit: charukiewicz)
2021-02-03 02:28:01 +0100charukiewicz(~quassel@irouteince04.i.subnet.rcn.com)
2021-02-03 02:28:09 +0100jollygood2(~bc8134e3@217.29.117.252) (Quit: http://www.okay.uz/ (Session timeout))
2021-02-03 02:28:27 +0100charukiewicz(~quassel@irouteince04.i.subnet.rcn.com) (Client Quit)
2021-02-03 02:29:52 +0100charukiewicz(~charukiew@irouteince04.i.subnet.rcn.com)
2021-02-03 02:32:20 +0100bitmapper(uid464869@gateway/web/irccloud.com/x-nvqzpcbpfmbefeds)
2021-02-03 02:32:28 +0100thefybe(~thefybe@249-147-161-N2.customer.vsm.sh)
2021-02-03 02:33:31 +0100thc202(~thc202@unaffiliated/thc202) (Ping timeout: 258 seconds)
2021-02-03 02:33:35 +0100Jd007(~Jd007@162.156.11.151) (Quit: Jd007)
2021-02-03 02:33:54 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 02:39:38 +0100stef204(~stef204@unaffiliated/stef-204/x-384198)
2021-02-03 02:45:43 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-03 02:46:04 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 02:49:14 +0100m0rphism1(~m0rphism@HSI-KBW-085-216-104-059.hsi.kabelbw.de) (Ping timeout: 258 seconds)
2021-02-03 02:50:46 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 258 seconds)
2021-02-03 02:52:38 +0100conal(~conal@64.71.133.70)
2021-02-03 02:56:03 +0100cheater1(~user@unaffiliated/cheater)
2021-02-03 02:58:45 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 02:58:53 +0100cheater(~user@unaffiliated/cheater) (Ping timeout: 265 seconds)
2021-02-03 02:58:57 +0100cheater1cheater
2021-02-03 03:00:39 +0100shinobi(~shinobi@c-24-147-48-162.hsd1.ma.comcast.net)
2021-02-03 03:00:53 +0100nuncanada(~dude@179.235.160.168)
2021-02-03 03:01:30 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl)
2021-02-03 03:02:45 +0100viluon(uid453725@gateway/web/irccloud.com/x-ksfxrsatayjgucds) (Quit: Connection closed for inactivity)
2021-02-03 03:03:31 +0100shinobi_(~shinobi@c-24-147-48-162.hsd1.ma.comcast.net) (Ping timeout: 272 seconds)
2021-02-03 03:04:04 +0100Jd007(~Jd007@162.156.11.151)
2021-02-03 03:06:45 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl) (Ping timeout: 240 seconds)
2021-02-03 03:11:57 +0100hyperisco(~hyperisco@104-195-141-253.cpe.teksavvy.com) (Ping timeout: 264 seconds)
2021-02-03 03:13:28 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:fc44:c2d6:2605:3850) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-03 03:13:30 +0100justsomeguy(~justsomeg@unaffiliated/--/x-3805311) (Quit: WeeChat 2.9)
2021-02-03 03:14:18 +0100guest23(~user@49.5.6.87)
2021-02-03 03:14:47 +0100 <guest23> I'm a little confused about Reader, when we need to use a Reader?
2021-02-03 03:15:34 +0100 <guest23> that Reader is just like a function, passing it a parameter and operate on it, what's the special? what's the need?
2021-02-03 03:15:39 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 03:17:10 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:fc44:c2d6:2605:3850)
2021-02-03 03:17:16 +0100 <dibblego> passing an argument through a tree of calls, without explicitly passing it in the code
2021-02-03 03:17:54 +0100 <guest23> a simple example?
2021-02-03 03:18:48 +0100 <guest23> if I declare the variable inside a function's top, then other functions insdie it could use it directly too
2021-02-03 03:23:09 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 272 seconds)
2021-02-03 03:23:10 +0100wz1000(~wz1000@static.11.113.47.78.clients.your-server.de) (Ping timeout: 272 seconds)
2021-02-03 03:26:34 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 03:28:08 +0100Jd007(~Jd007@162.156.11.151) (Quit: Jd007)
2021-02-03 03:28:39 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-03 03:30:00 +0100Noldorin(~noldorin@unaffiliated/noldorin) (Quit: My MacBook Pro has gone to sleep. ZZZzzz…)
2021-02-03 03:30:15 +0100xff0x_(~xff0x@2001:1a81:5334:6300:744e:2f9e:5495:d27d) (Ping timeout: 258 seconds)
2021-02-03 03:31:05 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 03:32:05 +0100xff0x_(~xff0x@2001:1a81:536f:2100:534e:8c50:d828:cc61)
2021-02-03 03:33:05 +0100 <ski> guest23 : sometimes you want to locally change the environment
2021-02-03 03:34:02 +0100Reiser(~0a2a0001@unaffiliated/reisen) (Ping timeout: 268 seconds)
2021-02-03 03:34:11 +0100 <ski> you can often achieve that, if you call an outer function that explicitly takes the parameter. but possibly sometimes that awkward, or maybe deemed to be to cluttery
2021-02-03 03:34:24 +0100 <ski> another alternative is to use implicit parameters
2021-02-03 03:36:02 +0100 <ski> guest23 : if you already have some effect type (monadic or idiomatic), then adding an environment to that is commonly an easy thing to do, while adding another explicit parameter that's distributed down the relevant calls may be quite a bit of more work/modification
2021-02-03 03:37:02 +0100_rht(uid86914@gateway/web/irccloud.com/x-ufajdipojemchcbz)
2021-02-03 03:37:23 +0100nfip^(nfip@ip98-184-89-2.mc.at.cox.net)
2021-02-03 03:38:07 +0100minimario(2fe3e53b@047-227-229-059.res.spectrum.com)
2021-02-03 03:39:10 +0100 <minimario> i'm trying to compile a haskell program with "ghc -prof A.hs" but i'm getting a linker error (`gcc' failed in phase `Linker') where it can't find things like -lHSsplit, how would i go about diagnosing this?
2021-02-03 03:39:46 +0100kloeri(~kloeri@freenode/staff/exherbo.kloeri) (Ping timeout: 606 seconds)
2021-02-03 03:40:03 +0100 <minimario> i have no idea how the linking process works at all :l
2021-02-03 03:40:05 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr)
2021-02-03 03:40:16 +0100 <glguy> minimario, How did you install GHC?
2021-02-03 03:40:50 +0100 <minimario> honestly i don't remember ):
2021-02-03 03:41:06 +0100 <glguy> That message suggests to me you didn't install the profiling version of the split package. but you really shouldn't be running ghc manually at all; cabal handles that
2021-02-03 03:42:23 +0100 <minimario> oh i'm just going thru a small profiling tutorial lol
2021-02-03 03:42:37 +0100 <minimario> is there some way to fix this?
2021-02-03 03:42:44 +0100 <minimario> (presumably by installing the packages needed)
2021-02-03 03:43:58 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 03:48:21 +0100Reiser(~0a2a0001@static.210.242.216.95.clients.your-server.de)
2021-02-03 03:50:01 +0100kloeri(~kloeri@freenode/staff/exherbo.kloeri)
2021-02-03 03:51:20 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 258 seconds)
2021-02-03 03:53:39 +0100 <glguy> minimario, I'd set up your thing.cabal file and use https://cabal.readthedocs.io/en/3.4/nix-local-build.html#how-can-i-profile-my-library-application
2021-02-03 03:54:06 +0100 <glguy> that will automatically build the profiling versions of the libraries as needed and set up profiling options
2021-02-03 03:58:30 +0100alx741(~alx741@181.196.69.29) (Quit: alx741)
2021-02-03 04:00:20 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 04:00:25 +0100nuncanada(~dude@179.235.160.168) (Quit: Leaving)
2021-02-03 04:00:37 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 04:04:55 +0100minimario(2fe3e53b@047-227-229-059.res.spectrum.com) (Quit: Connection closed)
2021-02-03 04:06:01 +0100minimario(2fe3e53b@047-227-229-059.res.spectrum.com)
2021-02-03 04:06:20 +0100pfurla_(~pfurla@239.15.195.173.client.static.strong-in52.as13926.net)
2021-02-03 04:06:42 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 246 seconds)
2021-02-03 04:08:35 +0100pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net) (Ping timeout: 258 seconds)
2021-02-03 04:10:25 +0100nineonin_(~nineonine@50.216.62.2) (Ping timeout: 240 seconds)
2021-02-03 04:11:04 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 04:13:34 +0100fresheyeball(~isaac@ec2-35-155-97-88.us-west-2.compute.amazonaws.com) (Ping timeout: 258 seconds)
2021-02-03 04:14:03 +0100Jd007(~Jd007@162.156.11.151)
2021-02-03 04:15:41 +0100fresheyeball(~isaac@c-71-237-105-37.hsd1.co.comcast.net)
2021-02-03 04:17:00 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 272 seconds)
2021-02-03 04:22:36 +0100theDon(~td@94.134.91.201) (Ping timeout: 240 seconds)
2021-02-03 04:22:50 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 04:23:50 +0100 <guest23> ski: so Reader is like a let-environment?
2021-02-03 04:24:06 +0100 <guest23> let in scheme
2021-02-03 04:24:23 +0100 <ski> more or less, yes
2021-02-03 04:24:30 +0100 <ski> (also `let' in Haskell)
2021-02-03 04:24:34 +0100theDon(~td@94.134.91.50)
2021-02-03 04:24:45 +0100 <Axman6> reader is like passing around an argument without having to remember to pass it around everywhere
2021-02-03 04:24:59 +0100 <guest23> ski: let in haskell is definetly not like let in scheme
2021-02-03 04:25:03 +0100 <ski> in fact, one of the uses of `Reader'/`ReaderT' would be to implement a local environment, in an interpreter, or a compiler
2021-02-03 04:25:11 +0100 <Axman6> if I'm operating inside a Reader env a, there at any time I can ask for the Env
2021-02-03 04:25:25 +0100mmmattyx(uid17782@gateway/web/irccloud.com/x-fhsjdgdsmsucvkhr) (Quit: Connection closed for inactivity)
2021-02-03 04:25:39 +0100 <ski> guest23 : i know. i was just saying that this aspect of `let' is shared by nested block structure in most programming languages
2021-02-03 04:25:40 +0100 <Axman6> it's very often used for passing around application configuration, like settings read fromt he command line which the rest of the app need to access
2021-02-03 04:26:39 +0100 <ski> (however, one subtlety would be static/lexical vs. dynamic scope, which matters when you can define local functions, which can access non-local variables)
2021-02-03 04:27:02 +0100 <guest23> ski: Axman6 wait a sec, but that Reader's envrionment is read-only right? so if we want to change variables in environment, use State?
2021-02-03 04:27:04 +0100 <Axman6> data Env = End {...; logLevel :: LogLevel; ...}; someFunction :: ReaderT Env IO (); someFunction = do { level <- gets logLevel; liftIO $ logAtLevel level "I ran someFunction" ... }
2021-02-03 04:27:16 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 04:27:19 +0100 <ski> guest23 : change, in which sense ?
2021-02-03 04:27:21 +0100 <Axman6> yes, that's why I said configuration and not state
2021-02-03 04:27:47 +0100 <ski> guest23 : you know environment variables in processes ?
2021-02-03 04:27:55 +0100 <guest23> ski: (let ((x 0)) (setq x 1)) ?
2021-02-03 04:28:15 +0100plutoniix(~q@ppp-27-55-78-115.revip3.asianet.co.th)
2021-02-03 04:28:39 +0100 <guest23> is this let-environment a closure?
2021-02-03 04:28:50 +0100 <ski> guest23 : Scheme implementations often implement that in terms of something like `(let ((x (box 0))) (set-box! x 1))', which now doesn't change `x', but rather the contents of the mutable box
2021-02-03 04:29:07 +0100 <Axman6> :t local
2021-02-03 04:29:08 +0100 <guest23> environment, context, namespace, are they same here?
2021-02-03 04:29:09 +0100 <lambdabot> MonadReader r m => (r -> r) -> m a -> m a
2021-02-03 04:29:21 +0100 <ski> so, `x' is still bound to the same value (a location), but if you look up that location in the store/state, you get a different result, after the `set-box!'
2021-02-03 04:29:51 +0100 <ski> guest23 : in Haskell, the same effect can be had by using e.g. `ReaderT (IORef Config) IO'
2021-02-03 04:30:01 +0100 <Axman6> we can temporarily change the environment in a Reader with local, so we can say: local (\env -> env {level = DEBUG} $ someActionWeAlwaysToLogAtLevelDEBUG
2021-02-03 04:30:28 +0100 <ski> guest23 : "is this let-environment a closure?" -- no
2021-02-03 04:30:49 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Ping timeout: 258 seconds)
2021-02-03 04:31:21 +0100 <ski> guest23 : "environment variables", like `$PATH',`$HOME', you know them ?
2021-02-03 04:31:47 +0100peasynt(~quassel@pool-173-76-103-124.bstnma.fios.verizon.net)
2021-02-03 04:32:15 +0100 <guest23> ski: not that system environment variables, I mean variables in a function
2021-02-03 04:32:29 +0100 <ski> yes, but there's a similarity
2021-02-03 04:33:42 +0100 <guest23> Axman6: wait a sec, but if Reader can do changes, why we need State?
2021-02-03 04:34:00 +0100 <ski> if you imagine that a process could only change its environment variables, when spawning a child process, and then only to change them, on behalf of the child, not for itself .. then that gives a nice analogy to environment/input/reader/config effects
2021-02-03 04:34:08 +0100 <Axman6> those changes are local to the action you pass to the function
2021-02-03 04:34:09 +0100 <guest23> I know Reader is an environment, Writer is a logger, and State is read-write
2021-02-03 04:34:25 +0100 <Axman6> nothing is _changed_, it's runnung an action in a new environment
2021-02-03 04:35:11 +0100 <ski> `local' would correspond to the spawn a child case. (of course there's no concurrency with `local', but there is the "locally change on behalf of child computation")
2021-02-03 04:36:55 +0100 <guest23> Reader's local only make an new environement to it's child, don't change the outside
2021-02-03 04:37:21 +0100 <Axman6> % :t local @Reader
2021-02-03 04:37:21 +0100 <yahb> Axman6: ; <interactive>:1:8: error:; * Expecting two more arguments to `Reader'; Expected a type, but `Reader' has kind `* -> * -> *'; * In the type `Reader'; In the expression: local @Reader
2021-02-03 04:37:34 +0100 <Axman6> % :t local @(Reader String)
2021-02-03 04:37:34 +0100 <yahb> Axman6: ; <interactive>:1:9: error:; * Expecting one more argument to `Reader String'; Expected a type, but `Reader String' has kind `* -> *'; * In the type `(Reader String)'; In the expression: local @(Reader String)
2021-02-03 04:37:54 +0100 <Axman6> % :t local @String @(Reader String)
2021-02-03 04:37:54 +0100 <yahb> Axman6: (String -> String) -> Reader String a -> Reader String a
2021-02-03 04:38:33 +0100 <ski> in Scheme, there's `(with-input-from-file filename (lambda () ...))' which evaluates `...' in a new dynamic *environment*, where `(current-input-port)' locally refers to the newly opened file. when this form is finished, it reverts back to its earlier value
2021-02-03 04:38:46 +0100 <Axman6> the Reader that is passed in sees the modified String environment, and its result is returned, but after local returns the environment is the same as it was before the local call
2021-02-03 04:38:53 +0100FinnElija(~finn_elij@gateway/tor-sasl/finnelija/x-67402716)
2021-02-03 04:38:53 +0100finn_elijaGuest39021
2021-02-03 04:38:53 +0100FinnElijafinn_elija
2021-02-03 04:39:02 +0100 <ski> using `local changeTheEnvironment (do ...)' in Haskell is similar in spirit
2021-02-03 04:39:14 +0100peasynt(~quassel@pool-173-76-103-124.bstnma.fios.verizon.net) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2021-02-03 04:39:35 +0100peasynt(~quassel@pool-173-76-103-124.bstnma.fios.verizon.net)
2021-02-03 04:39:40 +0100 <ski> guest23 : "Reader's local only make an new environement to it's child, don't change the outside" -- right
2021-02-03 04:39:51 +0100 <guest23> the Reader introduction should really write that "It's just let environement in Scheme", so it's easier to understand it
2021-02-03 04:40:12 +0100 <Axman6> I'm not sure it is the same though, there's no mutation
2021-02-03 04:40:30 +0100 <ski> guest23 : it would be misleading to say that, i think
2021-02-03 04:40:38 +0100 <ski> why Scheme, specifically ?
2021-02-03 04:40:55 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 04:41:05 +0100 <ski> (a) the correspondence holds to most notions of block structured scopes in programming languages
2021-02-03 04:41:28 +0100 <guest23> ski: I only know let in scheme is famous, other languages have let syntax sugar?
2021-02-03 04:41:55 +0100 <guest23> oh, let in scheme and common lisp are different
2021-02-03 04:42:05 +0100 <ski> (b) that correspondence can be seen to be about how said feature in programming languages are *implemented*. but using `Reader' is not (in general) about implementing programming languages (although that is one thing it can be used for)
2021-02-03 04:42:06 +0100Tario(~Tario@201.192.165.173) (Read error: Connection reset by peer)
2021-02-03 04:42:06 +0100noctux(~noctux@unaffiliated/noctux) (Ping timeout: 256 seconds)
2021-02-03 04:42:09 +0100 <guest23> one is a syntax sugar, another isn't
2021-02-03 04:42:23 +0100 <dibblego> \x -> f x (g x (h x x) (i (j x)) -- it's to stop having to write this, including in the implementations of each function
2021-02-03 04:42:38 +0100Guest39021(~finn_elij@gateway/tor-sasl/finnelija/x-67402716) (Ping timeout: 268 seconds)
2021-02-03 04:42:47 +0100 <ski> `let' is Scheme is a derived form. `(let ((x 0)) ..x..)' means `((lambda (x) ..x..) 0)'
2021-02-03 04:43:10 +0100Tario(~Tario@201.192.165.173)
2021-02-03 04:43:14 +0100AWizzArd(~code@unaffiliated/awizzard) (Ping timeout: 256 seconds)
2021-02-03 04:43:48 +0100cocreature(~cocreatur@eirene.uberspace.de) (Ping timeout: 256 seconds)
2021-02-03 04:44:08 +0100 <guest23> actually I'm learning arrow-kt in Kotlin, those monads are a kind of differntly to Haskell
2021-02-03 04:44:19 +0100 <ski> Scheme is a Lisp-1, while CL is a Lisp-2. Scheme binds functions in the same namespace as other variables, while CL doesn't. but this difference is immaterial, irrelevant, here
2021-02-03 04:44:52 +0100 <dibblego> because Kotlin's type system cannot express a monad
2021-02-03 04:45:00 +0100minimario(2fe3e53b@047-227-229-059.res.spectrum.com) (Quit: Connection closed)
2021-02-03 04:45:14 +0100 <ski> cannot express a monad, or cannot express "monad" ?
2021-02-03 04:45:21 +0100 <dibblego> the latter
2021-02-03 04:45:36 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 04:45:43 +0100abhixec(~abhixec@c-67-169-139-16.hsd1.ca.comcast.net) (Quit: leaving)
2021-02-03 04:45:44 +0100 <guest23> dibblego: with lex-syntax, we can avoid \x -> f x (g x (h x x) (i (j x)) too
2021-02-03 04:46:21 +0100skiidly wonders what guest23 has in mind
2021-02-03 04:46:30 +0100 <dibblego> ya can't actually
2021-02-03 04:47:08 +0100Jd007(~Jd007@162.156.11.151) (Quit: Jd007)
2021-02-03 04:47:31 +0100 <guest23> how to define and use Reader in a funciton form? not data type form?
2021-02-03 04:48:11 +0100wujilingfeng(df46f205@223.70.242.5)
2021-02-03 04:48:19 +0100wujilingfeng(df46f205@223.70.242.5) (Client Quit)
2021-02-03 04:48:36 +0100 <dibblego> Reader is, quite precisely, a function, with a data type wrapping it
2021-02-03 04:48:44 +0100wujilingfeng(df46f205@223.70.242.5)
2021-02-03 04:48:44 +0100ski. o O ( `f <*> (g <*> join h <*> (i <$> j))' )
2021-02-03 04:48:53 +0100 <dibblego> lol
2021-02-03 04:48:57 +0100wujilingfeng(df46f205@223.70.242.5) ()
2021-02-03 04:49:25 +0100shiraeeshi(~shiraeesh@77.94.25.42) (Quit: Konversation terminated!)
2021-02-03 04:49:41 +0100shiraeeshi(~shiraeesh@77.94.25.42)
2021-02-03 04:50:21 +0100 <guest23> to OOP, I think Reader is just like an object, an object itself has an environment
2021-02-03 04:50:51 +0100 <ski> it's unclear what you mean by "environment", there
2021-02-03 04:51:17 +0100 <guest23> namespace?
2021-02-03 04:51:33 +0100 <guest23> context?
2021-02-03 04:52:04 +0100 <dibblego> it's this, but done well, https://refactoring.com/catalog/replaceParameterWithQuery.html
2021-02-03 04:53:26 +0100renzhi(~renzhi@2607:fa49:6500:6f00::1e43) (Ping timeout: 258 seconds)
2021-02-03 04:53:42 +0100 <guest23> dibblego: yes, that's what I meant
2021-02-03 04:54:25 +0100pagnol(~user@n112120223083.netvigator.com)
2021-02-03 04:57:07 +0100 <guest23> if function f has two parameters called x and y, and in an let-environment x is defined, we can call (f y) in that environment, that's Reader?
2021-02-03 04:58:34 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 04:59:19 +0100nineonine(~nineonine@50.216.62.2)
2021-02-03 04:59:39 +0100Saukk(~Saukk@83-148-239-3.dynamic.lounea.fi)
2021-02-03 05:00:42 +0100 <ukari> https://hackage.haskell.org/package/dependent-map-0.4.0.0/src/LICENSE, does it means this package license is almost a BSD license and safe for static link?
2021-02-03 05:02:06 +0100Stanley00(~stanley00@unaffiliated/stanley00)
2021-02-03 05:02:22 +0100thefybe(~thefybe@249-147-161-N2.customer.vsm.sh) (Read error: Connection reset by peer)
2021-02-03 05:02:43 +0100thefybe(~thefybe@249-147-161-N2.customer.vsm.sh)
2021-02-03 05:03:05 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 05:04:07 +0100 <lyxia> ukari: that sounds about right
2021-02-03 05:06:03 +0100lep_(~lep@94.31.102.183)
2021-02-03 05:06:14 +0100 <ski> guest23 : there is no identifier correspond to `x', for `Reader'
2021-02-03 05:06:20 +0100lep_Guest18945
2021-02-03 05:06:54 +0100lep-delete(~lep@94.31.81.93) (Ping timeout: 246 seconds)
2021-02-03 05:07:59 +0100conal(~conal@64.71.133.70)
2021-02-03 05:08:27 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 05:08:36 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr) (Ping timeout: 240 seconds)
2021-02-03 05:09:13 +0100average(uid473595@gateway/web/irccloud.com/x-rtojiysrxktngdss)
2021-02-03 05:09:22 +0100 <guest23> ski: sorry, I don't what you mean
2021-02-03 05:09:39 +0100 <average> I think I just had this realization: The more I look at FP, the more it seems like it wants to do symbolic manipulation and symbolic computations, but it does't want to go all the way
2021-02-03 05:10:07 +0100 <ski> "in an let-environment x is defined, we can call (f y) in that environment" -- there's nothing corresponding to `x', for `Reader'
2021-02-03 05:10:09 +0100conal(~conal@64.71.133.70) (Client Quit)
2021-02-03 05:10:35 +0100 <average> is there a point to even do FP if we already have environments where we CAN do symbolic calculations ?
2021-02-03 05:10:51 +0100 <ski> average : with (analytic) meta-programming, you get to do more symbolic manipulation and computation
2021-02-03 05:11:45 +0100 <average> ski: well.. alright but in the end it is just a pattern-matching thing..
2021-02-03 05:11:49 +0100 <average> or term-rewriting if you will
2021-02-03 05:12:50 +0100rdivyanshu(uid322626@gateway/web/irccloud.com/x-mtieidadejfsxoah)
2021-02-03 05:13:37 +0100 <average> I feel like FP happened because a PLT person found themselves in a Computer Algebra or Symbolic Algebra context, they learned some techniques (but definitely not that much), and then they were like "Oh.My.God. I will re-package this and sell it as a NEW thing, and nobody will know, nobody will notice, I will call it Functional Programming"
2021-02-03 05:15:26 +0100 <average> idk, FP seems second-hand to me
2021-02-03 05:15:43 +0100 <average> it's like it came out of a thrift store
2021-02-03 05:15:46 +0100 <average> I'm just sayin..
2021-02-03 05:17:07 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 265 seconds)
2021-02-03 05:18:56 +0100shiraeeshi(~shiraeesh@77.94.25.42) (Ping timeout: 256 seconds)
2021-02-03 05:19:47 +0100 <ski> average : FP could perhaps have been said to have started with
2021-02-03 05:19:50 +0100 <ski> @where BAckus
2021-02-03 05:19:50 +0100 <lambdabot> "Can Programming Be Liberated from the von Neumann Style?: A Functional Style and Its Algebra of Programs" (Turing Award lecture) by John Warner Backus in 1977-10-17 at <https://amturing.acm.org/
2021-02-03 05:19:50 +0100 <lambdabot> award_winners/backus_0703524.cfm>,<http://www.thocp.net/biographies/papers/backus_turingaward_lecture.pdf>
2021-02-03 05:20:45 +0100 <ski> or perhaps with the invention of Lisp by John McCarthy, in 1958. or perhaps by the invention of the lambda calculus by Alonzo Church in the 1930s
2021-02-03 05:20:50 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 05:22:24 +0100 <ski> (although calculations in math, towards a normal form, prior to that, certainly contributed to inspiring that, and higher-order functions in math were certainly known before Church)
2021-02-03 05:23:35 +0100 <ski> another influential thing was ISWIM, introduced by Peter Landin in 1966 in his paper "The Next 700 Programming Languages" at <https://www.cs.cmu.edu/~crary/819-f09/Landin66.pdf>
2021-02-03 05:23:36 +0100jespada(~jespada@90.254.242.138) (Ping timeout: 240 seconds)
2021-02-03 05:24:50 +0100 <ski> (well, invention/discovery, in the case of the lambda calculus)
2021-02-03 05:24:51 +0100Tario(~Tario@201.192.165.173) (Read error: Connection reset by peer)
2021-02-03 05:25:04 +0100 <dolio> Bishop wrote an unpublished paper on how to compile mathematics into Algol in 1969, too.
2021-02-03 05:25:35 +0100Tario(~Tario@201.192.165.173)
2021-02-03 05:26:47 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 05:26:49 +0100jespada(~jespada@90.254.242.138)
2021-02-03 05:26:56 +0100 <ski> average : an important thing, in the lambda calculus, when seen as a term-rewriting system, is confluence
2021-02-03 05:27:05 +0100shiraeeshi(~shiraeesh@77.94.25.42)
2021-02-03 05:27:09 +0100 <ski> dolio : Errett ?
2021-02-03 05:27:13 +0100 <dolio> Yeah.
2021-02-03 05:27:48 +0100 <average> What I'd like to see is symbolic stuff baked into the language. But I think I already found out that the only things that satisfy my requirements..
2021-02-03 05:27:57 +0100 <average> are really just Mathematica and Maple, maybe not even those
2021-02-03 05:28:07 +0100 <ski> what kind of symbolic stuff ?
2021-02-03 05:28:17 +0100 <ski> evaluation under binders ?
2021-02-03 05:28:27 +0100 <ski> higher-order matching ?
2021-02-03 05:28:35 +0100AWizzArd(~code@gehrels.uberspace.de)
2021-02-03 05:29:03 +0100 <average> well..I guess there's two things that the language should do
2021-02-03 05:29:23 +0100 <average> 1) report errors according to the laws of the structures that were declared
2021-02-03 05:29:27 +0100 <guest23> ski: then what's the proper way to describe Reader?
2021-02-03 05:29:32 +0100 <average> 2) be able to figure out things on its own, without hand-holding
2021-02-03 05:30:05 +0100cocreature(~cocreatur@eirene.uberspace.de)
2021-02-03 05:30:27 +0100 <ski> guest23 : distribution of an environment/config, with the option to pass on a modified version, at each distribution point ?
2021-02-03 05:30:35 +0100 <average> the 1st one is actually the strongly-typed algebraic-type thing..
2021-02-03 05:30:45 +0100 <average> the 2nd one is more like Prolog, pattern-matching term-rewriting stuff
2021-02-03 05:31:00 +0100toorevitimirp(~tooreviti@117.182.181.145)
2021-02-03 05:31:00 +0100 <ski> 2) sounds pretty vague, i was about to say
2021-02-03 05:31:24 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 05:31:25 +0100 <ski> (although it did sound like some descriptions of how people perceive Prolog .. at least before they understand how it works)
2021-02-03 05:31:44 +0100 <ski> (and i'm not sure i understand what (1) means)
2021-02-03 05:32:13 +0100notzmv(~user@unaffiliated/zmv) (Ping timeout: 260 seconds)
2021-02-03 05:32:44 +0100 <average> ski: well what I mean in (1) is the fact that you can define monoids, groups, rings, whatever
2021-02-03 05:32:51 +0100 <average> ski: and you declare some axioms too..
2021-02-03 05:33:04 +0100thefybe(~thefybe@249-147-161-N2.customer.vsm.sh) (Ping timeout: 265 seconds)
2021-02-03 05:33:24 +0100 <ski> well, one problem is termination of equational axioms, used as rewrite rules
2021-02-03 05:33:24 +0100 <average> but actually all that stuff belongs to symbolic land.. it's not really an FP thing
2021-02-03 05:33:52 +0100 <average> so I'm not sure if I understand what FP's plan is
2021-02-03 05:33:53 +0100 <ski> (also, stuff like unification in the presence of an associative, and possibly commutative, operator)
2021-02-03 05:34:12 +0100cocreature(~cocreatur@eirene.uberspace.de) (Ping timeout: 246 seconds)
2021-02-03 05:34:14 +0100 <average> ski: sure, but that's like.. only teh beginning of symbolic stuff
2021-02-03 05:34:31 +0100 <ski> well, FP focuses on expressions which unambiguously denotes values, perhaps you could say
2021-02-03 05:34:31 +0100 <average> if we'd really want to do symbolic math, we'd go way beyond that and have way more difficult problems to deal with
2021-02-03 05:34:41 +0100 <ski> the terms are not the main thing
2021-02-03 05:35:40 +0100 <ski> anyway .. did you ever check out e.g. lambdaProlog, or Twelf ?
2021-02-03 05:35:42 +0100fresheyeball(~isaac@c-71-237-105-37.hsd1.co.comcast.net) (Quit: WeeChat 2.9)
2021-02-03 05:35:49 +0100 <average> honestly I did not
2021-02-03 05:36:05 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 05:36:31 +0100 <ski> it's probably not quite what you're looking for .. but possibly you'd find some things in them quite interesting
2021-02-03 05:36:45 +0100Tario(~Tario@201.192.165.173) (Ping timeout: 258 seconds)
2021-02-03 05:37:29 +0100 <ski> dolio : happen to know the title of it ? maybe there's even an online version of it, somewhere ?
2021-02-03 05:38:27 +0100 <dolio> https://u.math.biu.ac.il/~katzmik/bishop18bb.pdf
2021-02-03 05:38:54 +0100 <average> I think for me it's more of a realization that FP is not magic, and that the mathy parts in FP are really handled seriously and extensively in computer algebra or symbolic math CAS systems..
2021-02-03 05:39:04 +0100 <average> so I view FP as a toy now
2021-02-03 05:39:32 +0100 <ski> ty
2021-02-03 05:40:34 +0100 <ski> (dunno what you mean by "the mathy parts")
2021-02-03 05:41:16 +0100notzmv(~user@unaffiliated/zmv)
2021-02-03 05:41:28 +0100 <ski> (anyway .. i'm off, presently)
2021-02-03 05:42:01 +0100salumu(~sMuNiX@vlnsm8-montreal02-142-122-8-233.internet.virginmobile.ca)
2021-02-03 05:42:26 +0100conal(~conal@64.71.133.70)
2021-02-03 05:43:50 +0100Stanley00(~stanley00@unaffiliated/stanley00) (Remote host closed the connection)
2021-02-03 05:44:40 +0100 <average> basically what I'm trying to say is that Haskell is a CAS wannabe
2021-02-03 05:44:53 +0100 <average> at least at first sight
2021-02-03 05:45:03 +0100sMuNiX(~sMuNiX@vlnsm8-montreal02-142-122-8-233.internet.virginmobile.ca) (Ping timeout: 246 seconds)
2021-02-03 05:45:04 +0100 <average> but when you get closer to it, it turns out it's not a CAS..
2021-02-03 05:45:23 +0100 <monochrom> No, Haskell is not a CAS wannabe.
2021-02-03 05:45:28 +0100 <dolio> It doesn't seem like a CAS at all, to me.
2021-02-03 05:45:35 +0100 <average> and it's not particularly better at anything compared to other languages
2021-02-03 05:45:57 +0100 <dolio> It seems like you just want to get banned, really.
2021-02-03 05:46:13 +0100 <monochrom> I know we're talking about aspiration not actual outcome, but no, Haskell doesn't even aspire to that.
2021-02-03 05:46:27 +0100Stanley00(~stanley00@unaffiliated/stanley00)
2021-02-03 05:46:35 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 05:46:43 +0100_rht(uid86914@gateway/web/irccloud.com/x-ufajdipojemchcbz) (Quit: Connection closed for inactivity)
2021-02-03 05:46:44 +0100 <monochrom> IMO it is your association, not the Haskell inventors' association.
2021-02-03 05:47:27 +0100 <average> dolio: from time to time, I come here asking what exactly is Haskell made for. It's been years now. My expectation is that someone will explain "Haskell is best for writing programs that do X,Y,Z" (so better than any other language that you could use to write X,Y,Z) . I have not received this type of answer yet.
2021-02-03 05:48:11 +0100 <average> to me, complete mastery of a language means knowing what it's good at and what it's bad at.
2021-02-03 05:48:37 +0100 <average> so yes, I think the questions I'm asking are very pragmatic
2021-02-03 05:49:18 +0100 <average> dolio: if you're a PLT daydreamer, maybe you shouldn't read my questions and shouldn't try to answer them
2021-02-03 05:50:01 +0100 <average> monochrom: so what did the Haskell inventors have in mind ?
2021-02-03 05:50:39 +0100 <monochrom> I think SPJ has a paper on that?
2021-02-03 05:50:57 +0100mmohammadi9812(~mmohammad@2.178.169.112) (Ping timeout: 264 seconds)
2021-02-03 05:51:19 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 05:51:20 +0100 <monochrom> I think «a history of haskell: being lazy with class»?
2021-02-03 05:51:28 +0100mmohammadi9812(~mmohammad@188.210.119.142)
2021-02-03 05:51:37 +0100pfurla(~pfurla@ool-182ed2e2.dyn.optonline.net)
2021-02-03 05:51:50 +0100 <average> so.. an entire language just for lazy evaluation ?
2021-02-03 05:52:04 +0100 <average> or is that paper about something else ?
2021-02-03 05:52:04 +0100 <monochrom> You finished reading the whole paper already? Wow that's fast.
2021-02-03 05:52:19 +0100 <average> No i did not read it, I think it's a big commitment to read an entire paper
2021-02-03 05:52:38 +0100 <monochrom> Or you're just another slashdotter who read the title and stop reading and start tweeting?
2021-02-03 05:52:54 +0100 <average> monochrom: I'm more of a tl;dr guy
2021-02-03 05:52:57 +0100 <monochrom> You asked a big question you deserve a big paper.
2021-02-03 05:53:05 +0100 <Axman6> average: Facebook's spam filtering system is definitely not a CAS system... but it handles 2m+ messages/posts per second, all in Haskell
2021-02-03 05:53:25 +0100 <monochrom> And with that, I'm done. I pointed to a useful paper, enough said.
2021-02-03 05:53:41 +0100 <average> Axman6: yes and I'm very glad Facebook finally solved the spam problem. We all know when we go on Facebook there is literally no spam at all
2021-02-03 05:53:46 +0100 <average> Axman6: ok, that was my sarcasm
2021-02-03 05:53:50 +0100 <average> Axman6: but..
2021-02-03 05:54:00 +0100pfurla_(~pfurla@239.15.195.173.client.static.strong-in52.as13926.net) (Ping timeout: 258 seconds)
2021-02-03 05:54:05 +0100 <Axman6> "and it's not particularly better at anything compared to other languages " I'd strongly dispute this, the type system is the closest we have to a sweet spot for usability and power
2021-02-03 05:54:06 +0100 <average> Axman6: why did they pick Haskell to write their spam filtering system..
2021-02-03 05:54:38 +0100 <average> Axman6: but power of what..
2021-02-03 05:54:46 +0100 <Axman6> because Haskell's concurrency stuff is amazing, and its type system makes it very difficult for non programmers to write spam filtering rules
2021-02-03 05:54:59 +0100 <Axman6> which are correct*
2021-02-03 05:55:06 +0100 <average> but why do we want non-programmers writing programs ?
2021-02-03 05:55:18 +0100 <average> oh wait. just the rules ?
2021-02-03 05:55:19 +0100 <average> hm, ok
2021-02-03 05:55:22 +0100 <monochrom> wait, very difficult?
2021-02-03 05:55:30 +0100 <Axman6> because Facebook's spam filtering team is full of people who are not programmers per se
2021-02-03 05:55:34 +0100 <average> Axman6: so you're saying Haskell is very easy to write.. rule-systems ?
2021-02-03 05:55:56 +0100 <Axman6> I think that's a very narrow take away from what I said
2021-02-03 05:56:30 +0100 <monochrom> The problem with tldr
2021-02-03 05:57:18 +0100 <Axman6> the project I am currently working on is rewriting the clearing and settlement system for oneof the top stock markets in the world. We're not using Haskell as such, but a language which is basically Haskell++-- (haskell with some extra stuff and some stuff missing)
2021-02-03 05:58:17 +0100 <Axman6> Again, not a CAS at all, it's a something which underpins a large portion of the country's financial system
2021-02-03 05:58:53 +0100frozenErebus(~frozenEre@37.231.239.43)
2021-02-03 05:59:13 +0100 <average> Haskell would never pass an architectural board committee process.. unless.. you're the committee ..
2021-02-03 05:59:28 +0100 <Axman6> To answert an earlier statement you wanted a response to: Haskell is best for writing programs
2021-02-03 05:59:42 +0100 <average> so Haskell is best for writing programs?
2021-02-03 06:00:11 +0100 <Axman6> yes, it is a programming language, so writing programs it is what it's best for
2021-02-03 06:00:34 +0100 <average> I can easily say that answer didn't increase my understanding as to what Haskell is best at. because programs you can also write in Turbo Pascal.
2021-02-03 06:00:50 +0100 <average> or in Bash.
2021-02-03 06:01:26 +0100Brain007(~Brain007@124.123.104.217)
2021-02-03 06:01:35 +0100elliott__(~elliott@pool-108-51-101-42.washdc.fios.verizon.net) (Ping timeout: 265 seconds)
2021-02-03 06:01:41 +0100 <Axman6> what whgat is C best for? What is C++ best for? What is Java best for? What is Python best for?
2021-02-03 06:02:23 +0100 <average> there are answers for those..
2021-02-03 06:02:25 +0100 <Axman6> they have their niches of course, but all of them can be used for writing programs, so why should we have to limit what Haskell can be used for?
2021-02-03 06:02:31 +0100mmohammadi9812(~mmohammad@188.210.119.142) (Ping timeout: 256 seconds)
2021-02-03 06:02:32 +0100 <monochrom> Axman6, that's useless. They already have wrong answers for those question. They now want us to give similarly wrong answers for Haskell. You are just proving their point.
2021-02-03 06:02:38 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 06:02:44 +0100 <average> but.. are you suggesting it's down to a feeling/touchy-feely/office-politics decision-making ?
2021-02-03 06:02:52 +0100 <average> and that in fact, it doesn't even matter what it's best at ?
2021-02-03 06:02:56 +0100 <Axman6> of course it is, humans wrote programs
2021-02-03 06:03:01 +0100 <Axman6> write*
2021-02-03 06:03:15 +0100raym(~ray@45.64.220.55) (Quit: leaving)
2021-02-03 06:03:29 +0100ixaxaar(~ixaxaar@49.207.210.215)
2021-02-03 06:03:31 +0100raym(~ray@45.64.220.55)
2021-02-03 06:03:54 +0100 <glguy> There's no black and white set of things general purpose programming languages as best/worst at. You just have to weight the various strengths and weakness each has against the project at hand
2021-02-03 06:04:08 +0100Brain007(~Brain007@124.123.104.217) (Remote host closed the connection)
2021-02-03 06:04:47 +0100 <Axman6> I have written web services in Haskell for governments, data processing systems for large private companies, and now this financial system which interacts with banks and stock brokers. where is the commoin niche there? People have written operating systems, and systems for producing hard real time embedded code
2021-02-03 06:05:02 +0100lep-delete(~lep@94.31.81.183)
2021-02-03 06:06:13 +0100cocreature(~cocreatur@eirene.uberspace.de)
2021-02-03 06:06:20 +0100 <monochrom> https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/ while we are at it. (And SPJ again.)
2021-02-03 06:06:29 +0100mmohammadi9812(~mmohammad@188.210.119.142)
2021-02-03 06:06:33 +0100mmohammadi9812(~mmohammad@188.210.119.142) (Client Quit)
2021-02-03 06:06:49 +0100 <Axman6> "No one uses functional programming" "Wait, no, not like that!"
2021-02-03 06:06:52 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-03 06:07:07 +0100 <monochrom> My friend independently found https://visualstudiomagazine.com/articles/2021/01/27/excel-lambda.aspx?m=1
2021-02-03 06:07:23 +0100Guest18945(~lep@94.31.102.183) (Ping timeout: 265 seconds)
2021-02-03 06:07:37 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 256 seconds)
2021-02-03 06:08:36 +0100 <Axman6> My dad shared one of those articles with me a few weeks ago
2021-02-03 06:09:10 +0100 <Axman6> is... Excel just Lisp? D:
2021-02-03 06:09:27 +0100 <monochrom> Nah it doesn't have call/cc
2021-02-03 06:09:33 +0100 <Axman6> phew
2021-02-03 06:09:50 +0100 <monochrom> Does Excel have eval?
2021-02-03 06:10:42 +0100 <Axman6> ... yes, called EVALUATE
2021-02-03 06:10:45 +0100 <average> Does Haskell have parser generators, and generally the building blocks to produce compilers and interpreters bult into the language itself or at least in stdlib or.. at least in haskell-platfom ?
2021-02-03 06:10:45 +0100 <monochrom> In this sense: eval("A1+A2") is equivalent to =A1+A2
2021-02-03 06:11:03 +0100 <average> I mean maybe this is where Haskell shines? Building other languages..
2021-02-03 06:11:05 +0100 <Axman6> gmm, maybe not quite: https://www.myonlinetraininghub.com/excel-factor-12-secret-evaluate-function
2021-02-03 06:11:50 +0100soft-warm(4408f588@ip68-8-245-136.sd.sd.cox.net)
2021-02-03 06:13:15 +0100np(znc@152.67.162.71) ("WeeChat 2.9")
2021-02-03 06:13:49 +0100nerdypepper(znc@152.67.162.71)
2021-02-03 06:13:57 +0100 <monochrom> I think it qualifies, even though a bit inconvenient to use.
2021-02-03 06:14:23 +0100emptyflask(~jon@136.49.71.178) (Quit: WeeChat 2.9)
2021-02-03 06:15:05 +0100 <average> "While Haskell is a general purpose language that can be used in any domain and use case, it is ideally suited for proprietary business logic and data analysis[..]" says huffingyon post
2021-02-03 06:15:16 +0100 <average> So proprietary business logic huh ?
2021-02-03 06:15:39 +0100 <Axman6> yeah, a.k.a, "programs"
2021-02-03 06:15:39 +0100 <average> I have never seen a language sold like that..
2021-02-03 06:15:47 +0100 <glguy> Is the idea if you say something wrong that someone will correct you and keep it going?
2021-02-03 06:15:58 +0100 <average> Axman6: no but the key word here is proprietary
2021-02-03 06:16:00 +0100 <Axman6> specifically, "programs that do useful things"
2021-02-03 06:16:17 +0100 <average> So they are literally saying "Write your core business in Haskell"
2021-02-03 06:16:19 +0100 <Axman6> what's your point?
2021-02-03 06:16:23 +0100 <Axman6> yes
2021-02-03 06:16:41 +0100 <monochrom> I'm sure that shallow level of understanding is perfect for MBAs. You are ripe to go get an MBA for yourself and become a management type.
2021-02-03 06:18:07 +0100rayyyy(~nanoz@gateway/tor-sasl/nanoz)
2021-02-03 06:18:35 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 06:18:42 +0100noctux(~noctux@unaffiliated/noctux)
2021-02-03 06:19:06 +0100Saukk(~Saukk@83-148-239-3.dynamic.lounea.fi) (Remote host closed the connection)
2021-02-03 06:19:43 +0100shiraeeshi(~shiraeesh@77.94.25.42) (Quit: Konversation terminated!)
2021-02-03 06:19:56 +0100shiraeeshi(~shiraeesh@77.94.25.42)
2021-02-03 06:23:21 +0100noctux(~noctux@unaffiliated/noctux) (Ping timeout: 264 seconds)
2021-02-03 06:23:32 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 256 seconds)
2021-02-03 06:24:17 +0100soft-warm(4408f588@ip68-8-245-136.sd.sd.cox.net) (Ping timeout: 248 seconds)
2021-02-03 06:28:29 +0100deviantfero(~deviantfe@190.150.27.58) (Quit: WeeChat 3.0)
2021-02-03 06:29:10 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 06:30:00 +0100plutoniix(~q@ppp-27-55-78-115.revip3.asianet.co.th) (Read error: Connection reset by peer)
2021-02-03 06:33:31 +0100Wuzzy(~Wuzzy@p5b0df175.dip0.t-ipconnect.de)
2021-02-03 06:33:52 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 258 seconds)
2021-02-03 06:33:57 +0100noctux(~noctux@unaffiliated/noctux)
2021-02-03 06:34:35 +0100 <Axman6> Harsh
2021-02-03 06:34:45 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 06:38:28 +0100noctux(~noctux@unaffiliated/noctux) (Ping timeout: 258 seconds)
2021-02-03 06:38:52 +0100 <Axman6> average: how much of Facebook's core business is spam filtering? Clearly it's working for them, it's a substantial part of keeping the platform useful. Should they not have chosen Haskell?
2021-02-03 06:39:07 +0100 <Axman6> Should the various banks which rely on Haskell not?
2021-02-03 06:39:16 +0100noctux(~noctux@unaffiliated/noctux)
2021-02-03 06:39:23 +0100 <glguy> Should we not be chatting from Haskell??
2021-02-03 06:39:36 +0100 <Axman6> I am :)
2021-02-03 06:39:48 +0100Axman6<3 glguy
2021-02-03 06:39:54 +0100 <Axman6> I should probably update glirc...
2021-02-03 06:40:08 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 272 seconds)
2021-02-03 06:40:41 +0100 <glguy> Depending on how far back you are there were a few config changes
2021-02-03 06:40:51 +0100 <glguy> mostly around sasl; let me know if you need any help
2021-02-03 06:41:04 +0100 <Axman6> yeah I think I ran into those a while ago
2021-02-03 06:41:49 +0100geowiesnot(~user@87-89-181-157.abo.bbox.fr)
2021-02-03 06:42:38 +0100plutoniix(~q@184.82.199.202)
2021-02-03 06:45:18 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 06:46:27 +0100__minoru__shirae(~shiraeesh@109.166.56.27)
2021-02-03 06:47:21 +0100shiraeeshi(~shiraeesh@77.94.25.42) (Ping timeout: 264 seconds)
2021-02-03 06:47:52 +0100 <Axman6> Who do we praise to thank for the haskell type system? I'm reviewing some changes at the moment which are _massive_, hundreds of files changed, and all those changes were caught by the type system after a few relatively minor changes
2021-02-03 06:48:16 +0100 <Axman6> Hindley? Milner? SPJ?
2021-02-03 06:49:05 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:fc44:c2d6:2605:3850) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-03 06:49:25 +0100geowiesnot(~user@87-89-181-157.abo.bbox.fr) (Ping timeout: 240 seconds)
2021-02-03 06:49:56 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 06:50:44 +0100pagnol(~user@n112120223083.netvigator.com) (Ping timeout: 258 seconds)
2021-02-03 06:50:51 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-vebmjsskufunaflq) ()
2021-02-03 06:52:03 +0100pjb(~t@2a01cb04063ec50009186fab83b6d91d.ipv6.abo.wanadoo.fr) (Ping timeout: 272 seconds)
2021-02-03 06:53:50 +0100Tops21(~Tobias@dyndsl-095-033-093-253.ewe-ip-backbone.de)
2021-02-03 06:54:58 +0100 <monochrom> Hindley, Milner, Damas, Wadler (for type classes)
2021-02-03 06:55:18 +0100 <Axman6> Wadler it is then
2021-02-03 06:55:27 +0100 <monochrom> If you step outside of Haskell 2020 then you can include SPJ.
2021-02-03 06:56:29 +0100Tops2(~Tobias@dyndsl-095-033-022-141.ewe-ip-backbone.de) (Ping timeout: 258 seconds)
2021-02-03 07:02:39 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2021-02-03 07:03:45 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 07:04:34 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl)
2021-02-03 07:05:26 +0100stef204(~stef204@unaffiliated/stef-204/x-384198) (Ping timeout: 264 seconds)
2021-02-03 07:08:52 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 256 seconds)
2021-02-03 07:09:09 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 07:09:24 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 07:09:30 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 07:09:46 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 07:10:09 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl) (Ping timeout: 264 seconds)
2021-02-03 07:11:17 +0100dnlkrgr(~dnlkrgr@HSI-KBW-046-005-005-235.hsi8.kabel-badenwuerttemberg.de)
2021-02-03 07:15:06 +0100nineonine(~nineonine@50.216.62.2) (Ping timeout: 256 seconds)
2021-02-03 07:16:00 +0100desophos(~desophos@2601:249:1680:a570:a1da:e51c:3dc0:1f5c) (Quit: Leaving)
2021-02-03 07:16:40 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 07:16:48 +0100rzmt(~rzmt@87-92-180-112.rev.dnainternet.fi) (Ping timeout: 256 seconds)
2021-02-03 07:20:12 +0100seliopou(seliopou@entropy.tmok.com) (Ping timeout: 256 seconds)
2021-02-03 07:20:51 +0100seliopou(seliopou@entropy.tmok.com)
2021-02-03 07:20:51 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 07:21:01 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 07:22:25 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 07:22:38 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 07:22:45 +0100DTZUZU(~DTZUZU@205.ip-149-56-132.net)
2021-02-03 07:25:37 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 07:27:16 +0100dnlkrgr(~dnlkrgr@HSI-KBW-046-005-005-235.hsi8.kabel-badenwuerttemberg.de) (Ping timeout: 240 seconds)
2021-02-03 07:29:05 +0100Wuzzy(~Wuzzy@p5b0df175.dip0.t-ipconnect.de) (Remote host closed the connection)
2021-02-03 07:29:12 +0100pjb(~t@2a01cb04063ec5009d3731745487fa1c.ipv6.abo.wanadoo.fr)
2021-02-03 07:31:30 +0100rdivyanshu(uid322626@gateway/web/irccloud.com/x-mtieidadejfsxoah) (Quit: Connection closed for inactivity)
2021-02-03 07:34:53 +0100jamm_(~jamm@unaffiliated/jamm)
2021-02-03 07:36:45 +0100jamm_(~jamm@unaffiliated/jamm) (Remote host closed the connection)
2021-02-03 07:37:20 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 07:42:06 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 07:43:39 +0100lordie(~lordie@168.194.157.104)
2021-02-03 07:49:35 +0100nineonine(~nineonine@50.216.62.2)
2021-02-03 07:50:14 +0100rayyyy(~nanoz@gateway/tor-sasl/nanoz) (Remote host closed the connection)
2021-02-03 07:51:14 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 07:53:59 +0100nineonine(~nineonine@50.216.62.2) (Ping timeout: 258 seconds)
2021-02-03 07:54:36 +0100paintcan`(~user@cpe-69-206-241-99.nyc.res.rr.com) (Ping timeout: 240 seconds)
2021-02-03 07:55:54 +0100Lycurgus(~niemand@cpe-45-46-139-165.buffalo.res.rr.com) (Ping timeout: 256 seconds)
2021-02-03 07:56:07 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 272 seconds)
2021-02-03 07:56:17 +0100__minoru__shirae(~shiraeesh@109.166.56.27) (Ping timeout: 258 seconds)
2021-02-03 08:00:24 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net)
2021-02-03 08:02:29 +0100asheshambasta(~user@ptr-e1lysavd5pllo57cw5p.18120a2.ip6.access.telenet.be)
2021-02-03 08:04:20 +0100poljar1(~poljar@93-139-54-120.adsl.net.t-com.hr) (Ping timeout: 258 seconds)
2021-02-03 08:06:26 +0100catt(~r@31.124.181.226)
2021-02-03 08:07:20 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr)
2021-02-03 08:07:46 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 08:08:10 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 08:08:10 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 08:08:23 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 08:09:07 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 08:09:07 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 08:09:18 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 08:09:51 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2021-02-03 08:13:48 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 246 seconds)
2021-02-03 08:14:51 +0100danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa)
2021-02-03 08:15:06 +0100bitmagie(~Thunderbi@200116b806108700484948e27a931f58.dip.versatel-1u1.de)
2021-02-03 08:16:46 +0100thc202(~thc202@unaffiliated/thc202)
2021-02-03 08:17:16 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 08:18:05 +0100_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-02-03 08:18:29 +0100pagnol(~user@n112120223083.netvigator.com)
2021-02-03 08:18:40 +0100j2t(~user@84.122.202.215.dyn.user.ono.com)
2021-02-03 08:20:35 +0100rzmt(~rzmt@87-92-180-112.rev.dnainternet.fi)
2021-02-03 08:26:17 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa)
2021-02-03 08:27:04 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 08:27:14 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa) (Remote host closed the connection)
2021-02-03 08:27:47 +0100petersen(~petersen@redhat/juhp) (Ping timeout: 272 seconds)
2021-02-03 08:28:15 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa)
2021-02-03 08:31:25 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 08:32:42 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa) (Ping timeout: 258 seconds)
2021-02-03 08:33:02 +0100polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889) (Ping timeout: 260 seconds)
2021-02-03 08:34:29 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-03 08:36:04 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 08:36:49 +0100catt(~r@31.124.181.226) (Remote host closed the connection)
2021-02-03 08:38:05 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr) (Ping timeout: 240 seconds)
2021-02-03 08:39:11 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Ping timeout: 272 seconds)
2021-02-03 08:40:25 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 08:42:38 +0100average(uid473595@gateway/web/irccloud.com/x-rtojiysrxktngdss) (Quit: Connection closed for inactivity)
2021-02-03 08:43:54 +0100Sgeo(~Sgeo@ool-18b98aa4.dyn.optonline.net) (Read error: Connection reset by peer)
2021-02-03 08:45:02 +0100tzh(~tzh@c-24-21-73-154.hsd1.or.comcast.net) (Quit: zzz)
2021-02-03 08:45:56 +0100lawid(~quassel@dslb-090-186-099-248.090.186.pools.vodafone-ip.de) (Ping timeout: 240 seconds)
2021-02-03 08:48:30 +0100Guest62723(~ds@139.28.218.148) (Remote host closed the connection)
2021-02-03 08:50:04 +0100forgottenone(~forgotten@176.42.24.1)
2021-02-03 08:50:20 +0100lawid(~quassel@dslb-090-186-199-238.090.186.pools.vodafone-ip.de)
2021-02-03 08:50:47 +0100howdoi(uid224@gateway/web/irccloud.com/x-dcvsnpkbnllmgstf) (Quit: Connection closed for inactivity)
2021-02-03 08:52:22 +0100abian(~abian@185.204.1.185)
2021-02-03 08:52:41 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 08:52:44 +0100abianGuest38429
2021-02-03 08:57:12 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 246 seconds)
2021-02-03 09:00:07 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa)
2021-02-03 09:01:52 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa) (Remote host closed the connection)
2021-02-03 09:02:30 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa)
2021-02-03 09:03:12 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 09:07:12 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa) (Ping timeout: 258 seconds)
2021-02-03 09:07:38 +0100catt(~r@31.124.181.226)
2021-02-03 09:07:49 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 256 seconds)
2021-02-03 09:08:00 +0100bitmagie(~Thunderbi@200116b806108700484948e27a931f58.dip.versatel-1u1.de) (Quit: bitmagie)
2021-02-03 09:13:20 +0100polyrain(~polyrain@2001:8003:e4d8:4101:5d31:983b:a5a6:1f68)
2021-02-03 09:14:27 +0100dhouthoo(~dhouthoo@ptr-eitgbj2w0uu6delkbrh.18120a2.ip6.access.telenet.be)
2021-02-03 09:16:00 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-02-03 09:16:05 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-03 09:19:21 +0100polyrain(~polyrain@2001:8003:e4d8:4101:5d31:983b:a5a6:1f68) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-03 09:20:46 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 09:22:27 +0100charukiewicz(~charukiew@irouteince04.i.subnet.rcn.com) (Quit: charukiewicz)
2021-02-03 09:22:37 +0100cfricke(~cfricke@unaffiliated/cfricke) (Ping timeout: 260 seconds)
2021-02-03 09:25:33 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 265 seconds)
2021-02-03 09:27:20 +0100pagnol(~user@n112120223083.netvigator.com) (Remote host closed the connection)
2021-02-03 09:32:13 +0100polyrain(~polyrain@2001:8003:e4d8:4101:5d31:983b:a5a6:1f68)
2021-02-03 09:35:30 +0100rdivyanshu(uid322626@gateway/web/irccloud.com/x-lomphnhxhpzqtszd)
2021-02-03 09:35:39 +0100berberman(~berberman@unaffiliated/berberman) (Quit: ZNC 1.8.2 - https://znc.in)
2021-02-03 09:35:41 +0100miguel_clean(~Miguel@89-72-187-203.dynamic.chello.pl)
2021-02-03 09:36:00 +0100berberman(~berberman@unaffiliated/berberman)
2021-02-03 09:36:48 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 09:37:18 +0100jamm_(~jamm@unaffiliated/jamm)
2021-02-03 09:37:20 +0100carlomagno(~cararell@148.87.23.7) (Remote host closed the connection)
2021-02-03 09:37:30 +0100concept2(~concept2@unaffiliated/tubo) (Quit: Ping timeout (120 seconds))
2021-02-03 09:37:52 +0100carlomagno(~cararell@148.87.23.7)
2021-02-03 09:41:17 +0100concept2(~concept2@unaffiliated/tubo)
2021-02-03 09:41:42 +0100jamm_(~jamm@unaffiliated/jamm) (Ping timeout: 258 seconds)
2021-02-03 09:41:52 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 256 seconds)
2021-02-03 09:42:25 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 09:44:13 +0100Tops21(~Tobias@dyndsl-095-033-093-253.ewe-ip-backbone.de) (Read error: Connection reset by peer)
2021-02-03 09:45:46 +0100heatsink(~heatsink@2600:1700:bef1:5e10:d018:6f9c:3910:36c8) (Remote host closed the connection)
2021-02-03 09:47:20 +0100wz1000(~wz1000@static.11.113.47.78.clients.your-server.de)
2021-02-03 09:47:21 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 264 seconds)
2021-02-03 09:47:43 +0100Yumasi(~guillaume@2a01:e0a:5cb:4430:572d:5f36:41d6:1475)
2021-02-03 09:51:26 +0100rajivr(uid269651@gateway/web/irccloud.com/x-njsalrgkfquqyrca) (Quit: Connection closed for inactivity)
2021-02-03 09:51:54 +0100vikid(~vikid@bba428846.alshamil.net.ae) (Remote host closed the connection)
2021-02-03 09:52:01 +0100frozenErebus(~frozenEre@37.231.239.43) (Ping timeout: 256 seconds)
2021-02-03 09:52:16 +0100vikid(~vikid@83.110.238.94)
2021-02-03 09:56:05 +0100Major_Biscuit(~Major_Bis@82-169-100-198.biz.kpn.net)
2021-02-03 09:59:09 +0100raichoo(~raichoo@dslb-188-109-063-185.188.109.pools.vodafone-ip.de)
2021-02-03 10:00:00 +0100Noughtmare[m](naughtmare@gateway/shell/matrix.org/x-vwywabaoaoohawps) (Quit: Idle for 30+ days)
2021-02-03 10:00:17 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 10:00:49 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-03 10:01:38 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Client Quit)
2021-02-03 10:02:05 +0100Tuplanolla(~Tuplanoll@91-159-68-239.elisa-laajakaista.fi)
2021-02-03 10:02:05 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 10:02:36 +0100kuribas(~user@ptr-25vy0i8e6su9fkcjvkw.18120a2.ip6.access.telenet.be)
2021-02-03 10:03:25 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 10:05:19 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 272 seconds)
2021-02-03 10:07:30 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr)
2021-02-03 10:08:05 +0100chele(~chele@ip5b40237d.dynamic.kabel-deutschland.de)
2021-02-03 10:08:30 +0100mouseghost(~draco@wikipedia/desperek)
2021-02-03 10:08:36 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 10:09:24 +0100Franciman(~francesco@host-95-235-155-82.retail.telecomitalia.it)
2021-02-03 10:12:49 +0100pera(~pera@unaffiliated/pera)
2021-02-03 10:14:44 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr) (Ping timeout: 256 seconds)
2021-02-03 10:16:53 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 10:18:52 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net)
2021-02-03 10:21:02 +0100jluttine(~jluttine@85-23-95-149.bb.dnainternet.fi) (Ping timeout: 264 seconds)
2021-02-03 10:21:16 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 10:23:42 +0100chris8142(~chris8142@srvnet-01-071.ikbnet.co.at)
2021-02-03 10:23:45 +0100fearless_man(~fearless_@152.32.100.101) (Read error: Connection reset by peer)
2021-02-03 10:24:56 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl)
2021-02-03 10:29:49 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 10:30:22 +0100petersen(~petersen@redhat/juhp)
2021-02-03 10:33:02 +0100Varis(~Tadas@unaffiliated/varis)
2021-02-03 10:33:54 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 10:34:40 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 265 seconds)
2021-02-03 10:35:42 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 256 seconds)
2021-02-03 10:39:41 +0100livvy(~livvy@gateway/tor-sasl/livvy) (Quit: No Ping reply in 180 seconds.)
2021-02-03 10:40:35 +0100livvy(~livvy@gateway/tor-sasl/livvy)
2021-02-03 10:40:59 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-02-03 10:43:02 +0100polyrain(~polyrain@2001:8003:e4d8:4101:5d31:983b:a5a6:1f68) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-03 10:43:19 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-03 10:43:24 +0100lordie(~lordie@168.194.157.104) (Remote host closed the connection)
2021-02-03 10:43:32 +0100knupfer(~Thunderbi@mue-88-130-61-250.dsl.tropolys.de)
2021-02-03 10:44:15 +0100ubert(~Thunderbi@p200300ecdf25d95fe6b318fffe838f33.dip0.t-ipconnect.de)
2021-02-03 10:45:13 +0100ubert(~Thunderbi@p200300ecdf25d95fe6b318fffe838f33.dip0.t-ipconnect.de) (Remote host closed the connection)
2021-02-03 10:45:27 +0100rajivr(uid269651@gateway/web/irccloud.com/x-rezdfhgnedgqggyb)
2021-02-03 10:46:33 +0100heatsink(~heatsink@2600:1700:bef1:5e10:533:4549:6b9e:c969)
2021-02-03 10:49:06 +0100fendor(~fendor@91.141.2.117.wireless.dyn.drei.com)
2021-02-03 10:50:35 +0100Itkovian(~Itkovian@185.194.187.10)
2021-02-03 10:51:02 +0100heatsink(~heatsink@2600:1700:bef1:5e10:533:4549:6b9e:c969) (Ping timeout: 264 seconds)
2021-02-03 10:51:18 +0100hexo(~hexo@gateway/tor-sasl/hexo) (Remote host closed the connection)
2021-02-03 10:51:18 +0100srk(~sorki@gateway/tor-sasl/sorki) (Remote host closed the connection)
2021-02-03 10:51:20 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-02-03 10:51:40 +0100hexo(~hexo@gateway/tor-sasl/hexo)
2021-02-03 10:51:40 +0100srk(~sorki@gateway/tor-sasl/sorki)
2021-02-03 10:51:56 +0100 <ij> I read the first paragraph about performance and strictness in the wiki. -O gives me a 5x speedup :)
2021-02-03 10:51:58 +0100polyrain(~polyrain@2001:8003:e4d8:4101:5d31:983b:a5a6:1f68)
2021-02-03 10:53:16 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 256 seconds)
2021-02-03 10:56:29 +0100danza(~francesco@151.53.69.219)
2021-02-03 10:56:33 +0100vicfred(vicfred@gateway/vpn/mullvad/vicfred) (Ping timeout: 246 seconds)
2021-02-03 10:58:18 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 10:59:36 +0100gehmehgeh(~ircuser1@gateway/tor-sasl/gehmehgeh)
2021-02-03 10:59:49 +0100kritzefitz(~kritzefit@212.86.56.80)
2021-02-03 11:01:49 +0100ph88(~ph88@2a02:8109:9e00:7e5c:ade8:bbad:5afb:2c7)
2021-02-03 11:04:50 +0100sveit(~sveit@45.77.0.246) (Quit: Bye)
2021-02-03 11:04:59 +0100jamm_(~jamm@unaffiliated/jamm)
2021-02-03 11:05:09 +0100sveit(~sveit@45.77.0.246)
2021-02-03 11:05:44 +0100 <ph88> does someone know a package where Sørensen Dice is implemented ?
2021-02-03 11:05:58 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 11:15:30 +0100frozenErebus(~frozenEre@37.231.239.43)
2021-02-03 11:22:36 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 11:25:25 +0100j2t(~user@84.122.202.215.dyn.user.ono.com) (Ping timeout: 265 seconds)
2021-02-03 11:26:00 +0100Lord_of_Life_(~Lord@unaffiliated/lord-of-life/x-0885362)
2021-02-03 11:26:31 +0100quinn(~quinn@c-73-223-224-163.hsd1.ca.comcast.net) (Quit: ZNC 1.8.1 - https://znc.in)
2021-02-03 11:29:32 +0100Lord_of_Life(~Lord@unaffiliated/lord-of-life/x-0885362) (Ping timeout: 256 seconds)
2021-02-03 11:29:39 +0100Lord_of_Life_Lord_of_Life
2021-02-03 11:35:05 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 11:37:32 +0100Itkovian(~Itkovian@185.194.187.10) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-03 11:39:46 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 11:41:42 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-xrwggmicrnaussaz) (Quit: Connection closed for inactivity)
2021-02-03 11:41:42 +0100danza(~francesco@151.53.69.219) (Read error: Connection reset by peer)
2021-02-03 11:45:07 +0100rdivyanshu(uid322626@gateway/web/irccloud.com/x-lomphnhxhpzqtszd) (Quit: Connection closed for inactivity)
2021-02-03 11:47:32 +0100heatsink(~heatsink@2600:1700:bef1:5e10:cd3d:a18d:b2f7:b84a)
2021-02-03 11:50:16 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-03 11:50:21 +0100pera(~pera@unaffiliated/pera) (Quit: leaving)
2021-02-03 11:51:29 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 11:52:00 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 11:52:14 +0100heatsink(~heatsink@2600:1700:bef1:5e10:cd3d:a18d:b2f7:b84a) (Ping timeout: 264 seconds)
2021-02-03 11:53:35 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa)
2021-02-03 11:56:05 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 11:56:39 +0100 <ph88> can you test functions that are not exported by a module ?
2021-02-03 11:57:06 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 246 seconds)
2021-02-03 11:57:21 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 11:58:38 +0100m0rphism1(~m0rphism@HSI-KBW-085-216-104-059.hsi.kabelbw.de)
2021-02-03 11:58:56 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa) (Ping timeout: 258 seconds)
2021-02-03 12:01:05 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net) (Read error: Connection reset by peer)
2021-02-03 12:01:40 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net)
2021-02-03 12:02:21 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 246 seconds)
2021-02-03 12:02:21 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 12:02:31 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 12:02:44 +0100vicfred(vicfred@gateway/vpn/mullvad/vicfred)
2021-02-03 12:02:54 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 12:08:05 +0100Noldorin(~noldorin@unaffiliated/noldorin)
2021-02-03 12:09:17 +0100xff0x_(~xff0x@2001:1a81:536f:2100:534e:8c50:d828:cc61) (Ping timeout: 258 seconds)
2021-02-03 12:09:40 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 12:09:55 +0100 <edwardk> ph88: you should be able to implement a pretty nice version of that on top of something like hyperloglog in an efficient amount of space. not what you asked, but the first thing that came to mind
2021-02-03 12:10:17 +0100xff0x_(~xff0x@2001:1a81:536f:2100:2f3c:8f56:462:e9ab)
2021-02-03 12:11:07 +0100 <ph88> about Sørensen Dice ?
2021-02-03 12:11:18 +0100 <edwardk> yeah
2021-02-03 12:13:38 +0100Itkovian(~Itkovian@178-117-76-63.access.telenet.be)
2021-02-03 12:13:56 +0100danvet_(~danvet@212-51-149-181.fiber7.init7.net)
2021-02-03 12:14:39 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 12:15:58 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net) (Read error: Connection reset by peer)
2021-02-03 12:16:33 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net)
2021-02-03 12:18:52 +0100danvet_(~danvet@212-51-149-181.fiber7.init7.net) (Ping timeout: 258 seconds)
2021-02-03 12:19:35 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 272 seconds)
2021-02-03 12:19:45 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 12:20:24 +0100 <edwardk> dice x y = 2 * (fromIntegral <$> intersectionSize [x,y]) / (fromIntegral <$> (size x + size y))
2021-02-03 12:20:24 +0100 <edwardk> kind of blechy use of the Approximate Int64s there.
2021-02-03 12:20:31 +0100jamm_(~jamm@unaffiliated/jamm) (Remote host closed the connection)
2021-02-03 12:21:10 +0100 <edwardk> just like the fact that that uses the limited functionality offered by hyperloglog quite well
2021-02-03 12:22:22 +0100Lycurgus(~niemand@cpe-45-46-139-165.buffalo.res.rr.com)
2021-02-03 12:22:53 +0100 <edwardk> er i don't remember if approximates have a num instance actually
2021-02-03 12:24:14 +0100TommyC(~TommyC@unaffiliated/sepulchralbloom) (Ping timeout: 258 seconds)
2021-02-03 12:24:17 +0100jamm_(~jamm@unaffiliated/jamm)
2021-02-03 12:24:45 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-03 12:25:34 +0100aveltras(uid364989@gateway/web/irccloud.com/x-zridcshpxaalituf)
2021-02-03 12:25:42 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 12:26:04 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 12:29:09 +0100viluon(uid453725@gateway/web/irccloud.com/x-ucvzxcoudognhctl)
2021-02-03 12:30:32 +0100jamm_(~jamm@unaffiliated/jamm) (Remote host closed the connection)
2021-02-03 12:30:42 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 246 seconds)
2021-02-03 12:30:46 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net) (Read error: Connection reset by peer)
2021-02-03 12:31:38 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net)
2021-02-03 12:31:57 +0100TommyC(~TommyC@unaffiliated/sepulchralbloom)
2021-02-03 12:37:04 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-02-03 12:37:22 +0100meck(~meck@li1809-18.members.linode.com) (Quit: ZNC 1.8.2 - https://znc.in)
2021-02-03 12:39:07 +0100ph88^(~ph88@2a02:8109:9e00:7e5c:ade8:bbad:5afb:2c7)
2021-02-03 12:41:30 +0100meck(~meck@li1809-18.members.linode.com)
2021-02-03 12:41:47 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Ping timeout: 265 seconds)
2021-02-03 12:42:54 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 12:42:55 +0100ph88(~ph88@2a02:8109:9e00:7e5c:ade8:bbad:5afb:2c7) (Ping timeout: 272 seconds)
2021-02-03 12:45:45 +0100ukari(~ukari@unaffiliated/ukari) (Remote host closed the connection)
2021-02-03 12:46:10 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net) (Read error: Connection reset by peer)
2021-02-03 12:46:43 +0100LKoen(~LKoen@252.248.88.92.rev.sfr.net)
2021-02-03 12:47:01 +0100ukari(~ukari@unaffiliated/ukari)
2021-02-03 12:47:05 +0100Major_Biscuit(~Major_Bis@82-169-100-198.biz.kpn.net) (Ping timeout: 240 seconds)
2021-02-03 12:47:30 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 246 seconds)
2021-02-03 12:47:42 +0100turion(~turion@2a02:810d:8abf:c4a8:7417:1a58:4f1d:bffb)
2021-02-03 12:48:05 +0100mmohammadi9812(~mmohammad@198.12.95.171)
2021-02-03 12:49:41 +0100Major_Biscuit(~Major_Bis@x065156.citg-m.tudelft.nl)
2021-02-03 12:51:25 +0100plutoniix(~q@184.82.199.202) (Quit: Leaving)
2021-02-03 12:52:48 +0100joseph1(~joseph@cpe-65-31-18-174.insight.res.rr.com)
2021-02-03 12:54:30 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-02-03 12:58:40 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 13:01:19 +0100joseph1(~joseph@cpe-65-31-18-174.insight.res.rr.com) ("WeeChat 2.8")
2021-02-03 13:01:26 +0100ubert(~Thunderbi@2a02:8109:9880:303c:54a5:5901:5ae5:e9e0)
2021-02-03 13:01:28 +0100poljar(~poljar@78-3-15-134.adsl.net.t-com.hr)
2021-02-03 13:03:16 +0100swarmcollective(~joseph@cpe-65-31-18-174.insight.res.rr.com)
2021-02-03 13:03:22 +0100geyaeb(~geyaeb@gateway/tor-sasl/geyaeb) (Remote host closed the connection)
2021-02-03 13:03:42 +0100geyaeb(~geyaeb@gateway/tor-sasl/geyaeb)
2021-02-03 13:03:43 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 13:06:38 +0100damhiya(~damhiya@211.49.186.236)
2021-02-03 13:07:24 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 13:08:54 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Client Quit)
2021-02-03 13:09:02 +0100metreo(~Thunderbi@unaffiliated/metreo)
2021-02-03 13:09:16 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 13:09:31 +0100polyrain(~polyrain@2001:8003:e4d8:4101:5d31:983b:a5a6:1f68) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-03 13:09:32 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl)
2021-02-03 13:14:04 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 258 seconds)
2021-02-03 13:14:10 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl) (Ping timeout: 265 seconds)
2021-02-03 13:14:19 +0100 <Taneb> How do I make a template haskell Exp that represents the expression "Foo {..}" (with record wildcards)
2021-02-03 13:14:57 +0100Stanley00(~stanley00@unaffiliated/stanley00) ()
2021-02-03 13:16:10 +0100 <opqdonut> how about just doing something like $(show [|Foo {..}|]) to find out?
2021-02-03 13:16:38 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 13:16:48 +0100 <Taneb> RecConE name [], apparently, which is the same as for "Foo {}", which makes me suspicious
2021-02-03 13:17:07 +0100 <liyang> Does your Foo actually have any fields?
2021-02-03 13:17:10 +0100 <Taneb> Yes
2021-02-03 13:17:28 +0100 <liyang> How odd.
2021-02-03 13:19:22 +0100 <Taneb> Ah, [|let x = 1; y = True in Foo {..}|] gets something more complicated
2021-02-03 13:19:34 +0100 <Taneb> It's desugaring the record wildcard for me
2021-02-03 13:19:56 +0100vicfred(vicfred@gateway/vpn/mullvad/vicfred) (Read error: Connection reset by peer)
2021-02-03 13:19:58 +0100 <opqdonut> makes sense
2021-02-03 13:20:06 +0100 <Taneb> Which... I don't want it to do
2021-02-03 13:20:09 +0100 <opqdonut> so TH sees the syntax after RecordWildCards has been applied
2021-02-03 13:20:10 +0100vicfred(vicfred@gateway/vpn/mullvad/vicfred)
2021-02-03 13:20:11 +0100 <Taneb> (because I'm lazy)
2021-02-03 13:20:44 +0100 <liyang> Ah hah. Looking at some old code I think I came to the same conclusion.
2021-02-03 13:21:16 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 13:22:30 +0100 <liyang> Taneb: https://github.com/liyang/true-name/commit/3cd10547 if that helps.
2021-02-03 13:23:12 +0100 <Taneb> Thanks!
2021-02-03 13:23:14 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 13:25:34 +0100 <maralorn> ph88: Regarding "testing functions that are not exported by a module". Short answer: no, Long answer: https://www.tweag.io/blog/2021-01-07-haskell-dark-arts-part-i/
2021-02-03 13:28:25 +0100 <kuribas> doesn't GADTs destroy parametricity properties? For example for "[] a", a can be anything, there is no way to know what a means, but for "Expr a", you can know a is some finite set of values.
2021-02-03 13:28:26 +0100 <liyang> maralorn: Nice! Relevant to my interests. Never occured to me you could do that.
2021-02-03 13:29:02 +0100knupfer(~Thunderbi@mue-88-130-61-250.dsl.tropolys.de) (Quit: knupfer)
2021-02-03 13:29:15 +0100 <kuribas> So a GADT is not just a generalization, but also change the properties of the type system...
2021-02-03 13:29:43 +0100knupfer(~Thunderbi@200116b82c27b900d0584795dc7022de.dip.versatel-1u1.de)
2021-02-03 13:31:07 +0100 <merijn> kuribas: Why does it destroy parametricity?
2021-02-03 13:31:37 +0100 <kuribas> merijn: because now you have more information about a
2021-02-03 13:31:47 +0100 <merijn> What information, exactly?
2021-02-03 13:32:02 +0100 <kuribas> if you have a constructor, the exact type of a
2021-02-03 13:33:20 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 13:33:59 +0100 <ph88^> how can i write code so that i can map while performing IO action which can fail ?
2021-02-03 13:34:13 +0100 <kuribas> ph88^: traverse?
2021-02-03 13:34:29 +0100 <kuribas> ph88^: also, define fail?
2021-02-03 13:34:44 +0100 <kuribas> could be an exception, could be returning Either Error a ...
2021-02-03 13:35:15 +0100 <ph88^> Either
2021-02-03 13:35:22 +0100knupfer(~Thunderbi@200116b82c27b900d0584795dc7022de.dip.versatel-1u1.de) (Remote host closed the connection)
2021-02-03 13:35:25 +0100 <kuribas> ph88^: wrap with ExceptT, then traverse
2021-02-03 13:36:02 +0100 <ph88^> can i just use Either too ?
2021-02-03 13:36:46 +0100dyeplexer(~lol@unaffiliated/terpin)
2021-02-03 13:36:50 +0100 <kuribas> :t traverse (ExceptT . f)
2021-02-03 13:36:51 +0100 <lambdabot> (Traversable t, Monad m, Show a, FromExpr (m (Either e b))) => t a -> ExceptT e m (t b)
2021-02-03 13:36:58 +0100 <kuribas> :t \f -> traverse (ExceptT . f)
2021-02-03 13:36:59 +0100 <lambdabot> (Traversable t, Monad m) => (a -> m (Either e b)) -> t a -> ExceptT e m (t b)
2021-02-03 13:37:20 +0100 <ph88^> what's the difference between map and traverse ?
2021-02-03 13:38:05 +0100 <kuribas> ph88^: traverse also performs the effect
2021-02-03 13:38:13 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 13:38:26 +0100 <kuribas> > map putStrLn [1, 2, 3]
2021-02-03 13:38:28 +0100 <lambdabot> error:
2021-02-03 13:38:28 +0100 <lambdabot> • No instance for (Num String) arising from the literal ‘1’
2021-02-03 13:38:28 +0100 <lambdabot> • In the expression: 1
2021-02-03 13:38:37 +0100 <kuribas> > map putStrLn ["a", "b", "c"]
2021-02-03 13:38:38 +0100 <lambdabot> [<IO ()>,<IO ()>,<IO ()>]
2021-02-03 13:38:43 +0100 <kuribas> > traverse putStrLn ["a", "b", "c"]
2021-02-03 13:38:45 +0100 <lambdabot> <IO [()]>
2021-02-03 13:39:22 +0100 <ph88^> how can i combine traverse, ExceptT and evalState (from State) ?
2021-02-03 13:39:25 +0100damhiya(~damhiya@211.49.186.236) (Quit: WeeChat 3.0.1)
2021-02-03 13:39:48 +0100 <kuribas> ph88^: mapping an action over a list gives you a list of actions, traversing it gives you a list of the action results (in the action).
2021-02-03 13:40:16 +0100kritzefitz(~kritzefit@212.86.56.80) (Ping timeout: 240 seconds)
2021-02-03 13:40:20 +0100 <kuribas> ph88^: no IO?
2021-02-03 13:40:29 +0100 <ph88^> also IO ...
2021-02-03 13:40:58 +0100 <kuribas> you can make a stack ExceptT Err (StateT IO) a
2021-02-03 13:41:50 +0100 <kuribas> which is equivalent to s -> IO (s, Either Err a)
2021-02-03 13:41:51 +0100Tops2(~Tobias@dyndsl-095-033-093-253.ewe-ip-backbone.de)
2021-02-03 13:41:51 +0100 <ph88^> then i first unwrap the Except (maybe case match on Either ?) then when i have the Right condition i do runState on it ?
2021-02-03 13:42:08 +0100 <kuribas> ph88^: you unwrap from outside to inside.
2021-02-03 13:42:22 +0100 <ph88^> as i was saying it, it's from outside to inside, no ?
2021-02-03 13:42:50 +0100 <kuribas> flip evalStateT s $ runExceptT action
2021-02-03 13:43:12 +0100 <int-e> ski: I really hate the name `asTypeIn` because it raises more questions than it answers... maybe it should be `asArgOf`.
2021-02-03 13:43:39 +0100 <ph88^> thx kuribas i will try
2021-02-03 13:44:28 +0100 <ph88^> kuribas, what should be the signature i want to apply to the elements in this case ?
2021-02-03 13:44:37 +0100 <ph88^> the signature of the function *
2021-02-03 13:45:06 +0100 <kuribas> ph88^: you can make the function return the monad stack
2021-02-03 13:45:16 +0100 <ph88^> ok
2021-02-03 13:45:28 +0100 <kuribas> then unpack after traversing
2021-02-03 13:45:34 +0100 <kuribas> unwrap better
2021-02-03 13:46:06 +0100 <ph88^> how come here ExceptT Err (StateT IO) a a is not wrapped in IO ?
2021-02-03 13:46:30 +0100 <kuribas> because a is the return value of the monad stack
2021-02-03 13:46:47 +0100 <kuribas> which has to be the last type parameter
2021-02-03 13:47:08 +0100 <opqdonut> @unmtl ExceptT Err (StateT IO) a
2021-02-03 13:47:08 +0100 <lambdabot> err: `StateT IO (Either Err a)' is not applied to enough arguments, giving `/\A. IO -> Either Err a (A, IO)'
2021-02-03 13:47:18 +0100 <opqdonut> @unmtl ExceptT Err (StateT s IO) a
2021-02-03 13:47:18 +0100 <lambdabot> s -> IO (Either Err a, s)
2021-02-03 13:47:18 +0100pja(~phil@2a02:8010:6098:0:f2de:f1ff:fe2c:3d9) (Quit: WeeChat 2.8)
2021-02-03 13:47:22 +0100 <ph88^> but i want to map a function over a structure which needs access to IO and to State ... so dunno how that could return a value not wrapped in IO ..
2021-02-03 13:47:26 +0100stef204(~stef204@unaffiliated/stef-204/x-384198)
2021-02-03 13:47:44 +0100 <kuribas> opqdonut: right, I had the state switched...
2021-02-03 13:48:16 +0100 <kuribas> ph88^: it *does* return a value wrapped in IO
2021-02-03 13:48:21 +0100heatsink(~heatsink@2600:1700:bef1:5e10:cd3d:a18d:b2f7:b84a)
2021-02-03 13:48:35 +0100 <ph88^> why is it not written like (IO a) then ?
2021-02-03 13:48:54 +0100 <ph88^> or (StateT s (IO a))
2021-02-03 13:49:12 +0100 <kuribas> ph88^: because you only get the IO after unwrapping
2021-02-03 13:49:36 +0100 <ph88^> ok
2021-02-03 13:49:36 +0100carldd11(~carldd@90-224-49-113-no56.tbcn.telia.com) (Read error: Connection reset by peer)
2021-02-03 13:50:01 +0100 <kuribas> :t \s -> flip evalState s . runExceptT
2021-02-03 13:50:04 +0100 <lambdabot> s -> ExceptT e (StateT s Identity) a -> Either e a
2021-02-03 13:50:12 +0100 <kuribas> :t \s -> flip evalStateT s . runExceptT
2021-02-03 13:50:13 +0100 <lambdabot> Monad m => s -> ExceptT e (StateT s m) a -> m (Either e a)
2021-02-03 13:50:38 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-02-03 13:50:49 +0100Tario(~Tario@201.192.165.173)
2021-02-03 13:51:45 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 13:51:48 +0100 <ph88^> :t \b -> \s -> (\a -> evalState a s) $ runExcept b
2021-02-03 13:51:50 +0100 <lambdabot> error:
2021-02-03 13:51:50 +0100 <lambdabot> • Couldn't match type ‘Either e a’ with ‘StateT s Identity a1’
2021-02-03 13:51:50 +0100 <lambdabot> Expected type: State s a1
2021-02-03 13:52:14 +0100 <ph88^> why is that not the same ?
2021-02-03 13:52:39 +0100 <kuribas> because it's different? what's that a?
2021-02-03 13:52:56 +0100 <ph88^> i dunno
2021-02-03 13:52:57 +0100 <int-e> :t \b -> (\s -> (\a -> evalState a s)) $ runExcept b
2021-02-03 13:52:59 +0100 <int-e> :t \b -> (\s -> (\a -> evalState a s)) $ runExcept b
2021-02-03 13:53:01 +0100 <lambdabot> Except e a1 -> State (Either e a1) a2 -> a2
2021-02-03 13:53:26 +0100heatsink(~heatsink@2600:1700:bef1:5e10:cd3d:a18d:b2f7:b84a) (Ping timeout: 264 seconds)
2021-02-03 13:53:28 +0100 <int-e> ph88^: your $ is inside the innermost lambda
2021-02-03 13:53:48 +0100 <kuribas> ph88^: evalStateT takes two arguments, the monad stack and the state. You give it three arguments.
2021-02-03 13:53:56 +0100 <ph88^> i was trying to recreate \s -> flip evalStateT s . runExceptT without flip and .
2021-02-03 13:54:08 +0100 <int-e> :t \b -> (\s a -> evalState a s) $ runExcept b
2021-02-03 13:54:09 +0100 <lambdabot> Except e a1 -> State (Either e a1) a2 -> a2
2021-02-03 13:54:29 +0100 <int-e> :t \b a -> evalState a (runExcept b)
2021-02-03 13:54:30 +0100 <lambdabot> Except e a1 -> State (Either e a1) a2 -> a2
2021-02-03 13:54:37 +0100 <kuribas> :t \s m -> evalStateT (runExceptT m) s -- ph88^
2021-02-03 13:54:38 +0100 <lambdabot> Monad m => s -> ExceptT e (StateT s m) a -> m (Either e a)
2021-02-03 13:55:11 +0100 <ph88^> thanks
2021-02-03 13:55:35 +0100 <int-e> oh
2021-02-03 13:55:55 +0100 <ph88^> where in this does my function go that i want to map over the elements ?
2021-02-03 13:56:05 +0100knupfer(~Thunderbi@200116b82c27b900ad15eb691b6438af.dip.versatel-1u1.de)
2021-02-03 13:56:14 +0100 <int-e> the s got lost in translation
2021-02-03 13:56:27 +0100pja(~phil@2a02:8010:6098:0:f2de:f1ff:fe2c:3d9)
2021-02-03 13:56:37 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 13:57:30 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 246 seconds)
2021-02-03 13:57:36 +0100 <kuribas> :t \s f -> flip evalStateT s . runExceptT . traverse f -- ph88^
2021-02-03 13:57:37 +0100 <lambdabot> (Monad m, Traversable t) => s -> (a -> ExceptT e (StateT s m) b) -> t a -> m (Either e (t b))
2021-02-03 13:59:58 +0100chris8142(~chris8142@srvnet-01-071.ikbnet.co.at) ("WeeChat 3.0")
2021-02-03 14:00:04 +0100 <ph88^> :t \s f -> evalStateT (runExceptT (traverse f)) s
2021-02-03 14:00:06 +0100 <lambdabot> error:
2021-02-03 14:00:06 +0100 <lambdabot> • Couldn't match expected type ‘ExceptT e (StateT s m) a1’
2021-02-03 14:00:06 +0100 <lambdabot> with actual type ‘t0 a -> f (t0 b)’
2021-02-03 14:00:59 +0100 <ph88^> :t \s f m -> evalStateT (runExceptT m (traverse f)) s
2021-02-03 14:01:00 +0100 <lambdabot> error:
2021-02-03 14:01:00 +0100 <lambdabot> • Couldn't match type ‘Either e a1’ with ‘StateT s m a2’
2021-02-03 14:01:00 +0100 <lambdabot> Expected type: (t a -> f (t b)) -> StateT s m a2
2021-02-03 14:01:08 +0100carldd11(~carldd@90-224-49-113-no56.tbcn.telia.com)
2021-02-03 14:01:55 +0100 <kuribas> ph88^: you have to apply traverse to something
2021-02-03 14:02:06 +0100 <ph88^> oki
2021-02-03 14:02:08 +0100 <kuribas> :t traverse
2021-02-03 14:02:10 +0100 <lambdabot> (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
2021-02-03 14:04:05 +0100Tario(~Tario@201.192.165.173) (Ping timeout: 240 seconds)
2021-02-03 14:05:45 +0100 <kuribas> ph88^: a . b == \t -> a (b t)
2021-02-03 14:06:02 +0100urodna(~urodna@unaffiliated/urodna)
2021-02-03 14:06:26 +0100 <kuribas> so "\s f -> flip evalStateT s . runExceptT . traverse f" => \s f -> \t -> flip evalStateT s (runExceptT (traverse f t))
2021-02-03 14:06:51 +0100 <kuribas> apply flip and curry => \s f t -> evalStateT (runExceptT (traverse f t)) s
2021-02-03 14:07:28 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus)
2021-02-03 14:07:45 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 14:09:21 +0100hekkaidekapus}(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 268 seconds)
2021-02-03 14:09:39 +0100Rudd0(~Rudd0@185.189.115.108) (Ping timeout: 258 seconds)
2021-02-03 14:09:44 +0100michalz(~user@185.246.204.78)
2021-02-03 14:10:08 +0100 <kuribas> ph88^: it's often a good idea to do rewrite steps in order.
2021-02-03 14:10:35 +0100 <kuribas> these could be even automated by some tool ...
2021-02-03 14:12:09 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-03 14:12:41 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 256 seconds)
2021-02-03 14:16:21 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 14:16:50 +0100average(uid473595@gateway/web/irccloud.com/x-rcklrhokomuilocj)
2021-02-03 14:18:34 +0100berberman_(~berberman@unaffiliated/berberman)
2021-02-03 14:19:50 +0100berberman(~berberman@unaffiliated/berberman) (Ping timeout: 264 seconds)
2021-02-03 14:20:27 +0100honigkuchen(~honigkuch@ip5b429953.dynamic.kabel-deutschland.de)
2021-02-03 14:20:55 +0100 <honigkuchen> how would you program the smallest rule in a programming language, because whatsoever is a rule in essence?
2021-02-03 14:20:57 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 246 seconds)
2021-02-03 14:23:52 +0100danza(~francesco@151.53.69.219)
2021-02-03 14:24:21 +0100 <merijn> EQUESTIONILLDEFINED
2021-02-03 14:24:32 +0100geekosaur(82650c7c@130.101.12.124)
2021-02-03 14:25:21 +0100 <carbolymer> how can I get number of seconds from UTCTime?
2021-02-03 14:25:24 +0100jb55(~jb55@gateway/tor-sasl/jb55) (Remote host closed the connection)
2021-02-03 14:25:26 +0100 <carbolymer> I mean timestamp
2021-02-03 14:25:39 +0100 <liyang> carbolymer: number of seconds from when?
2021-02-03 14:25:47 +0100jb55(~jb55@gateway/tor-sasl/jb55)
2021-02-03 14:25:47 +0100o1lo01ol1o(~o1lo01ol1@bl7-89-228.dsl.telepac.pt) (Remote host closed the connection)
2021-02-03 14:25:48 +0100 <carbolymer> liyang: timestamp
2021-02-03 14:26:43 +0100 <carbolymer> Unix time precisely
2021-02-03 14:26:45 +0100 <liyang> carbolymer: 1970-01-01 00:00:00 UTC?
2021-02-03 14:26:55 +0100 <carbolymer> yes
2021-02-03 14:27:18 +0100jespada(~jespada@90.254.242.138) (Quit: Leaving)
2021-02-03 14:27:24 +0100 <carbolymer> utcTimeToPOSIXSeconds
2021-02-03 14:27:26 +0100 <carbolymer> oh
2021-02-03 14:27:26 +0100 <liyang> carbolymer: http://hackage.haskell.org/package/time-1.11.1.1/docs/Data-Time-Clock-POSIX.html#v:utcTimeToPOSIXS…
2021-02-03 14:27:36 +0100 <carbolymer> liyang: thx
2021-02-03 14:28:22 +0100 <liyang> If you'd rather have it as something other than NominalDiffTime, just wrap realToFrac around it.
2021-02-03 14:28:26 +0100TommyC(~TommyC@unaffiliated/sepulchralbloom) (Ping timeout: 258 seconds)
2021-02-03 14:29:33 +0100 <carbolymer> hmm
2021-02-03 14:29:44 +0100 <carbolymer> how do I convert NominalDiffTime -> Integer ?
2021-02-03 14:30:18 +0100 <liyang> carbolymer: in what units? Seconds, microseconds, picoseconds?
2021-02-03 14:30:31 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-03 14:30:52 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 14:31:03 +0100 <carbolymer> liyang: yeah, still talking about seconds
2021-02-03 14:31:04 +0100jamm_(~jamm@unaffiliated/jamm)
2021-02-03 14:31:23 +0100 <liyang> carbolymer: round ndt, round (ndt * 1000000), round (ndt * 1e12)
2021-02-03 14:31:29 +0100 <carbolymer> liyang: in general I would like nanos, but UTCTime is in seconds, right?
2021-02-03 14:31:36 +0100 <liyang> carbolymer: or ceil / floor.
2021-02-03 14:32:18 +0100 <liyang> UTCTime has ps precision, but fromInteger 1 :: NominalDiffTime is interpreted as 1 second.
2021-02-03 14:32:43 +0100 <merijn> UTCTime isn't in seconds, it's picoseconds
2021-02-03 14:33:07 +0100 <carbolymer> wait, UTCTime has Num instance?
2021-02-03 14:33:11 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 14:33:13 +0100 <liyang> (sssh! internal implementation detail.)
2021-02-03 14:33:49 +0100 <liyang> carbolymer: no, that wouldn't make sense. For a Num instance you'd need to define e.g. (+), and it doesn't make sense to add two UTCTimes.
2021-02-03 14:33:52 +0100 <merijn> UTCTime doesn't have a num instance
2021-02-03 14:34:26 +0100 <carbolymer> right, I meant NominalDiffTime
2021-02-03 14:34:33 +0100 <carbolymer> yes it has
2021-02-03 14:34:36 +0100 <liyang> Think of UTCTime as a point (in a 1D space), and NominalDiffTime as a vector.
2021-02-03 14:34:39 +0100 <carbolymer> that basically solves everything
2021-02-03 14:34:41 +0100 <carbolymer> thanks
2021-02-03 14:35:20 +0100jamm_(~jamm@unaffiliated/jamm) (Ping timeout: 258 seconds)
2021-02-03 14:35:57 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 264 seconds)
2021-02-03 14:38:25 +0100Sgeo(~Sgeo@ool-18b98aa4.dyn.optonline.net)
2021-02-03 14:39:05 +0100lotuseater(~user@ip-176-198-181-127.hsi05.unitymediagroup.de) (Read error: Connection reset by peer)
2021-02-03 14:39:10 +0100berberman_(~berberman@unaffiliated/berberman) (Quit: ZNC 1.8.2 - https://znc.in)
2021-02-03 14:39:32 +0100berberman(~berberman@unaffiliated/berberman)
2021-02-03 14:40:20 +0100digia(~digia@unaffiliated/digia) (Quit: Beep Boop...)
2021-02-03 14:40:51 +0100digia(~digia@unaffiliated/digia)
2021-02-03 14:41:01 +0100berberman(~berberman@unaffiliated/berberman) (Max SendQ exceeded)
2021-02-03 14:41:31 +0100berberman(~berberman@unaffiliated/berberman)
2021-02-03 14:41:58 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:fc44:c2d6:2605:3850)
2021-02-03 14:42:04 +0100esph(~weechat@unaffiliated/esph) (Ping timeout: 240 seconds)
2021-02-03 14:43:05 +0100esph(~weechat@unaffiliated/esph)
2021-02-03 14:45:11 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr)
2021-02-03 14:45:45 +0100frozenErebus(~frozenEre@37.231.239.43) (Ping timeout: 240 seconds)
2021-02-03 14:49:56 +0100heatsink(~heatsink@2600:1700:bef1:5e10:cd3d:a18d:b2f7:b84a)
2021-02-03 14:51:20 +0100 <honigkuchen> merijn, ?
2021-02-03 14:52:12 +0100geowiesnot(~user@i15-les02-ix2-87-89-181-157.sfr.lns.abo.bbox.fr) (Ping timeout: 258 seconds)
2021-02-03 14:52:21 +0100mmohammadi9812(~mmohammad@198.12.95.171) (Read error: Connection reset by peer)
2021-02-03 14:52:57 +0100Lycurgus(~niemand@cpe-45-46-139-165.buffalo.res.rr.com) (Quit: Exeunt)
2021-02-03 14:52:57 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 14:52:59 +0100mmohammadi9812(~mmohammad@2.178.213.79)
2021-02-03 14:53:10 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 14:53:22 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2021-02-03 14:53:23 +0100Wuzzy(~Wuzzy@p5b0df175.dip0.t-ipconnect.de)
2021-02-03 14:53:51 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 246 seconds)
2021-02-03 14:54:17 +0100ArConan(9de62a69@157.230.42.105)
2021-02-03 14:54:40 +0100 <ArConan> @src action
2021-02-03 14:54:40 +0100 <lambdabot> Source not found. :(
2021-02-03 14:54:42 +0100o1lo01ol1o(~o1lo01ol1@bl7-89-228.dsl.telepac.pt)
2021-02-03 14:54:42 +0100o1lo01ol1o(~o1lo01ol1@bl7-89-228.dsl.telepac.pt) (Remote host closed the connection)
2021-02-03 14:54:47 +0100o1lo01ol_(~o1lo01ol1@bl7-89-228.dsl.telepac.pt)
2021-02-03 14:54:53 +0100 <ArConan> @src fmap
2021-02-03 14:54:53 +0100 <lambdabot> Source not found. Are you typing with your feet?
2021-02-03 14:55:14 +0100heatsink(~heatsink@2600:1700:bef1:5e10:cd3d:a18d:b2f7:b84a) (Ping timeout: 264 seconds)
2021-02-03 14:55:22 +0100 <geekosaur> fmap is defined per instance
2021-02-03 14:55:23 +0100 <Taneb> ArConan: @src isn't very good (I think it's manually curated)
2021-02-03 14:55:29 +0100 <maerwald> @src map
2021-02-03 14:55:29 +0100 <lambdabot> map _ [] = []
2021-02-03 14:55:30 +0100 <lambdabot> map f (x:xs) = f x : map f xs
2021-02-03 14:55:33 +0100 <geekosaur> @src [] fmap
2021-02-03 14:55:33 +0100 <lambdabot> fmap = map
2021-02-03 14:56:17 +0100 <maerwald> @src Maybe fmap
2021-02-03 14:56:17 +0100 <lambdabot> fmap _ Nothing = Nothing
2021-02-03 14:56:17 +0100 <lambdabot> fmap f (Just a) = Just (f a)
2021-02-03 14:57:16 +0100raichoo(~raichoo@dslb-188-109-063-185.188.109.pools.vodafone-ip.de) (Quit: Lost terminal)
2021-02-03 14:57:24 +0100 <merijn> Taneb: It's just a text to text lookup, yeah
2021-02-03 14:57:38 +0100 <merijn> It's mostly the reference definition of the Haskell Report
2021-02-03 14:58:28 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 14:58:43 +0100Tario(~Tario@201.192.165.173)
2021-02-03 14:58:51 +0100TommyC(~TommyC@unaffiliated/sepulchralbloom)
2021-02-03 15:04:09 +0100vicfred(vicfred@gateway/vpn/mullvad/vicfred) (Quit: Leaving)
2021-02-03 15:05:42 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 15:08:20 +0100hyperisco(~hyperisco@104-195-141-253.cpe.teksavvy.com)
2021-02-03 15:09:33 +0100TommyC(~TommyC@unaffiliated/sepulchralbloom) (Ping timeout: 264 seconds)
2021-02-03 15:09:34 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-03 15:09:35 +0100berberman(~berberman@unaffiliated/berberman) (Quit: ZNC 1.8.2 - https://znc.in)
2021-02-03 15:09:47 +0100alx741(~alx741@181.196.69.29)
2021-02-03 15:09:56 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 15:10:00 +0100berberman(~berberman@unaffiliated/berberman)
2021-02-03 15:10:05 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 15:10:39 +0100turion(~turion@2a02:810d:8abf:c4a8:7417:1a58:4f1d:bffb) (Quit: Leaving.)
2021-02-03 15:10:47 +0100berberman(~berberman@unaffiliated/berberman) (Max SendQ exceeded)
2021-02-03 15:11:32 +0100berberman(~berberman@unaffiliated/berberman)
2021-02-03 15:14:49 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 258 seconds)
2021-02-03 15:17:02 +0100geekosaur(82650c7c@130.101.12.124) (Ping timeout: 240 seconds)
2021-02-03 15:22:44 +0100zaquest(~notzaques@5.128.210.178) (Quit: Leaving)
2021-02-03 15:23:16 +0100mmohammadi9812(~mmohammad@2.178.213.79) (Ping timeout: 240 seconds)
2021-02-03 15:24:23 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 15:25:04 +0100renzhi(~renzhi@2607:fa49:6500:6f00::1e43)
2021-02-03 15:26:10 +0100zaquest(~notzaques@5.128.210.178)
2021-02-03 15:27:03 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:fc44:c2d6:2605:3850) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-03 15:27:19 +0100 <ph88^> so ExceptT is not really an exception but just a monad ?
2021-02-03 15:27:53 +0100deviantfero(~deviantfe@190.150.27.58)
2021-02-03 15:27:58 +0100geekosaur(ac3a8ee4@172.58.142.228)
2021-02-03 15:28:00 +0100TommyC(~TommyC@unaffiliated/sepulchralbloom)
2021-02-03 15:29:30 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 265 seconds)
2021-02-03 15:31:10 +0100 <tdammers> it's a monad *transformer*
2021-02-03 15:31:29 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net)
2021-02-03 15:32:21 +0100 <maerwald> yeah, it has nothing to do with exceptions, which is why EitherT was a better name
2021-02-03 15:32:33 +0100 <maerwald> or ErrorT
2021-02-03 15:32:38 +0100frozenErebus(~frozenEre@37.231.239.43)
2021-02-03 15:32:47 +0100shiraeeshi(~shiraeesh@109.166.56.5)
2021-02-03 15:33:49 +0100 <merijn> except refers to exceptional as in "non-standard" not exceptions in the Control.Exception sense, though
2021-02-03 15:34:12 +0100 <merijn> maerwald: ErrorT was deprecated because Left isn't necessarily an *error*
2021-02-03 15:34:42 +0100 <maerwald> merijn: sure, it's just naming bikeshedding, but I've heard ppl often associate ExceptT with checked exeptions
2021-02-03 15:35:00 +0100pera(~pera@unaffiliated/pera)
2021-02-03 15:35:11 +0100 <ph88^> when there is a monad transformer does it always use the Identity monad to make the default case ?
2021-02-03 15:35:19 +0100 <maerwald> if those are checked exceptions, then I can have checked exceptions in C too
2021-02-03 15:35:28 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 15:35:42 +0100 <ph88^> what is a checked exception ?
2021-02-03 15:36:34 +0100 <maerwald> checked exceptions is about runtime guarantees, not types
2021-02-03 15:36:45 +0100 <pjb> maerwald: more precisely, the C standard has sufficient undefined behavior that a C implementation can specify and implement useful checked exception.
2021-02-03 15:37:22 +0100 <pjb> maerwald: but since this wouldn't be standard, it could be problematic using them. This would render your C code unportable. (Agreed, you could use some macros to paper over that).
2021-02-03 15:37:47 +0100 <nshepperd> the fact that it's not called EitherT feels bad tbh
2021-02-03 15:38:32 +0100 <ph88^> kuribas are you here ?
2021-02-03 15:38:40 +0100 <merijn> pjb: Well, it'd render your C code "not C"
2021-02-03 15:40:03 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 246 seconds)
2021-02-03 15:42:19 +0100 <kuribas> ph88^: yes
2021-02-03 15:42:34 +0100ph88_(~ph88@ip5f5af71a.dynamic.kabel-deutschland.de)
2021-02-03 15:43:58 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Quit: mputz)
2021-02-03 15:43:58 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2021-02-03 15:44:18 +0100 <pjb> merijn: it would still be C, just C with undefined behavior.
2021-02-03 15:44:36 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2021-02-03 15:44:43 +0100 <pjb> merijn: if you write int c=a+b; you have written C with undefined behavior.
2021-02-03 15:44:49 +0100pzzl(~pzzl@eimer.scc.uni-weimar.de)
2021-02-03 15:45:46 +0100ArConan(9de62a69@157.230.42.105) (Quit: Ping timeout (120 seconds))
2021-02-03 15:45:57 +0100ph88^(~ph88@2a02:8109:9e00:7e5c:ade8:bbad:5afb:2c7) (Ping timeout: 272 seconds)
2021-02-03 15:46:46 +0100 <ph88_> can someone help me with monad transformers ? https://bpa.st/VPJQ
2021-02-03 15:46:55 +0100 <pjb> merijn: to write C without undefined behavior, you need to write int c=(a>0)?((MAX_INT-a)>=b?a+b:0):((b>0)?((MAX_INT-b)>=a?a+b:0):((MIN_INT-a)<=b?a+b:0)); or something like that…
2021-02-03 15:46:56 +0100geekosaur(ac3a8ee4@172.58.142.228) (Quit: Ping timeout (120 seconds))
2021-02-03 15:47:06 +0100mmohammadi9812(~mmohammad@2.178.213.79)
2021-02-03 15:47:16 +0100 <ph88_> line 33 in the paste where things start going wrong
2021-02-03 15:48:20 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2021-02-03 15:51:06 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus) (Ping timeout: 268 seconds)
2021-02-03 15:52:00 +0100 <swarmcollective> ';
2021-02-03 15:52:48 +0100 <swarmcollective> ph88_ To begin, I don't believe you need "pure" there.
2021-02-03 15:53:10 +0100hekkaidekapus[(~tchouri@gateway/tor-sasl/hekkaidekapus)
2021-02-03 15:53:44 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 15:55:47 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa)
2021-02-03 15:57:43 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa) (Remote host closed the connection)
2021-02-03 15:58:24 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa)
2021-02-03 15:58:45 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 264 seconds)
2021-02-03 15:59:36 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 240 seconds)
2021-02-03 15:59:48 +0100 <kuribas> ph88_: you do "pure $ Right $ " on something that can give an error
2021-02-03 16:00:36 +0100 <kuribas> ph88_: also, personal opinion "f >>= \x -> body" is more ugly than "do x <- f; body"
2021-02-03 16:00:37 +0100mouseghost(~draco@wikipedia/desperek) (Quit: mew wew)
2021-02-03 16:00:51 +0100 <kuribas> the sugar is there, so use it.
2021-02-03 16:01:04 +0100gxt(~gxt@gateway/tor-sasl/gxt)
2021-02-03 16:01:37 +0100dminuososometimes prefers the `f >>= \x -> body` style
2021-02-03 16:01:48 +0100 <merijn> "It Depends (TM)"
2021-02-03 16:01:50 +0100 <dminuoso> Especially for a one-liner like that. :)
2021-02-03 16:02:47 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa) (Ping timeout: 260 seconds)
2021-02-03 16:03:57 +0100 <kuribas> ph88_: if you swap StateT and ExceptT you can pass the error on.
2021-02-03 16:04:08 +0100 <kuribas> dminuoso: the do is smaller
2021-02-03 16:04:20 +0100 <kuribas> dminuoso: you gain nothing with the >>= \x style.
2021-02-03 16:04:39 +0100darjeeling_(~darjeelin@122.245.120.134) (Ping timeout: 258 seconds)
2021-02-03 16:04:48 +0100 <kuribas> assuming it's production code, not an exercise for a beginner to learn how do notation works.
2021-02-03 16:05:16 +0100 <dminuoso> `do x <- f; body` reads very irregular to me.
2021-02-03 16:05:18 +0100p-core(~Thunderbi@2001:718:1e03:5128:3697:eeda:19aa:8e56)
2021-02-03 16:05:20 +0100 <maerwald> hmm, does partial pattern matching in lambda even trigger monadfail?
2021-02-03 16:05:27 +0100 <merijn> maerwald: no
2021-02-03 16:05:28 +0100 <dminuoso> No.
2021-02-03 16:05:33 +0100forgottenone(~forgotten@176.42.24.1) (Quit: Konversation terminated!)
2021-02-03 16:05:35 +0100 <maerwald> right, so it's not really the same
2021-02-03 16:05:52 +0100 <dminuoso> That's a bit nitpicky, but fine.
2021-02-03 16:06:23 +0100vicfred(~vicfred@unaffiliated/vicfred)
2021-02-03 16:06:23 +0100darjeeling_(~darjeelin@122.245.120.134)
2021-02-03 16:06:47 +0100 <ph88_> kuribas, do you mean to change the stack ?
2021-02-03 16:06:48 +0100 <merijn> kuribas: If you meant using do with the *actual* semicolon, rather than a newline, then I'm gonna change my opinion from "it depends" to "that's absolutely not acceptable" >.>
2021-02-03 16:06:54 +0100 <kuribas> ph88_: yes
2021-02-03 16:07:02 +0100raichoo(~raichoo@dslb-188-109-063-185.188.109.pools.vodafone-ip.de)
2021-02-03 16:07:05 +0100deviantfero(~deviantfe@190.150.27.58) (Ping timeout: 240 seconds)
2021-02-03 16:07:39 +0100 <kuribas> merijn: I sometimes use a semicolon, but not often...
2021-02-03 16:08:17 +0100raym(~ray@45.64.220.55) (Quit: leaving)
2021-02-03 16:08:29 +0100 <dminuoso> I like code to have a clear visual flow, which is why I alternate between =<< and >>= depending on the context of the code
2021-02-03 16:08:38 +0100guest23(~user@49.5.6.87) (Remote host closed the connection)
2021-02-03 16:08:45 +0100 <dminuoso> Generally preferring =<< though, just not when there's a lambda involved.
2021-02-03 16:08:46 +0100 <kuribas> I often use =<< and >>=, but never with a lambda
2021-02-03 16:08:59 +0100guest23(~user@49.5.6.87)
2021-02-03 16:10:27 +0100toorevitimirp(~tooreviti@117.182.181.145) (Remote host closed the connection)
2021-02-03 16:10:28 +0100 <maerwald> Never understood why ppl actively avoid lambdas :)
2021-02-03 16:10:36 +0100 <dminuoso> `instance Traversable Maybe`
2021-02-03 16:10:41 +0100 <dminuoso> My favourite instance of the month.
2021-02-03 16:10:42 +0100 <kuribas> maerwald: I don't?
2021-02-03 16:10:45 +0100 <merijn> maerwald: Lambda's are great, especially with stuff like forM :>
2021-02-03 16:11:07 +0100 <dminuoso> merijn: forM Im not quite convinced. But forM_ sure
2021-02-03 16:11:13 +0100geyaeb(~geyaeb@gateway/tor-sasl/geyaeb) (Remote host closed the connection)
2021-02-03 16:11:15 +0100 <maerwald> kuribas: using too many lambdas got me rejected at a job (they argued it's not advanced haskell)
2021-02-03 16:11:16 +0100 <maerwald> :D
2021-02-03 16:11:24 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 16:11:29 +0100 <dminuoso> If you're rebuilding structure, chances is you will want the function named so its clear what this builds up
2021-02-03 16:11:30 +0100 <ph88_> what is the tradeoff by changing the order of a monad transformer stack ?
2021-02-03 16:11:33 +0100 <kuribas> maerwald: people are idiots
2021-02-03 16:11:40 +0100 <dminuoso> ph88_: it changes the effect, usually
2021-02-03 16:11:47 +0100 <ph88_> what effect ?
2021-02-03 16:11:57 +0100 <dminuoso> It often means something different if you swap the order.
2021-02-03 16:11:59 +0100geyaeb(~geyaeb@gateway/tor-sasl/geyaeb)
2021-02-03 16:12:05 +0100 <maerwald> kuribas: I trolled back by telling them that pointfree style can lead to memory leaks (and it can)
2021-02-03 16:12:07 +0100 <dminuoso> It depends on the transformers involved
2021-02-03 16:12:35 +0100 <maerwald> but that's so rare that the average programmer probably doesn't need to care
2021-02-03 16:12:36 +0100 <kuribas> maerwald: besides, if they pick you or not based on just style, you don't want to work there anyway.
2021-02-03 16:12:56 +0100toorevitimirp(~tooreviti@117.182.181.145)
2021-02-03 16:13:25 +0100paintcan`(~user@cpe-69-206-241-99.nyc.res.rr.com)
2021-02-03 16:14:06 +0100 <dminuoso> ph88_: Consider the difference between `MaybeT (StateT Identity Int)` and `StateT Int (MaybeT Identity)` when throwing an exception in MaybeT with respect to state.
2021-02-03 16:14:25 +0100 <maerwald> I haven't experienced that much picking on style elsewhere though. E.g. in Go tech challenges, ppl usually care about performance only
2021-02-03 16:14:27 +0100 <kuribas> ph88_: in general, the inner monad takes preference. Which means inner state is still passed when you throw an exception.
2021-02-03 16:14:55 +0100 <kuribas> ph88_: if you move state to the outside, it doesn't. But for your code that doesn't matter.
2021-02-03 16:15:19 +0100bitmagie(~Thunderbi@200116b806108700484948e27a931f58.dip.versatel-1u1.de)
2021-02-03 16:15:26 +0100 <dminuoso> @unmtl MaybeT (StateT Int Identity) ()
2021-02-03 16:15:26 +0100 <lambdabot> Int -> (Maybe (), Int)
2021-02-03 16:15:28 +0100 <dminuoso> @unmtl StateT Int (MaybeT Identity) ()
2021-02-03 16:15:28 +0100 <lambdabot> Int -> Maybe ((), Int)
2021-02-03 16:15:35 +0100 <dminuoso> Those are clearly not the same thing. :)
2021-02-03 16:15:56 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 240 seconds)
2021-02-03 16:16:03 +0100 <ph88_> ye they look different
2021-02-03 16:18:03 +0100 <ph88_> how can i put these together ? newtype ExceptT e (m :: * -> *) a newtype StateT s (m :: * -> *) a
2021-02-03 16:18:44 +0100conal(~conal@64.71.133.70)
2021-02-03 16:18:44 +0100 <ph88_> can * -> * be written with arguments like a lambda function ?
2021-02-03 16:18:59 +0100Major_Biscuit(~Major_Bis@x065156.citg-m.tudelft.nl) (Ping timeout: 272 seconds)
2021-02-03 16:19:33 +0100 <kuribas> ph88_: like I said, it doesn't matter, since you don't need state in your exceptions.
2021-02-03 16:20:03 +0100 <ph88_> then how to handle code_lookup ?
2021-02-03 16:20:26 +0100bitmagie(~Thunderbi@200116b806108700484948e27a931f58.dip.versatel-1u1.de) (Quit: bitmagie)
2021-02-03 16:20:43 +0100 <ph88_> line 37 and 52
2021-02-03 16:21:11 +0100Major_Biscuit(~Major_Bis@82.169.100.198)
2021-02-03 16:21:17 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl)
2021-02-03 16:21:30 +0100 <kuribas> ph88_: just swap the types, and the unwrappers.
2021-02-03 16:21:53 +0100 <ph88_> yes that's what i'm trying, but i don't know how the types work so i was just asking about it
2021-02-03 16:22:12 +0100kritzefitz(~kritzefit@212.86.56.80)
2021-02-03 16:22:30 +0100texasmynsted_(~texasmyns@99.96.221.112)
2021-02-03 16:22:39 +0100 <kuribas> what don't you understand?
2021-02-03 16:22:51 +0100 <ph88_> what's a ?
2021-02-03 16:22:52 +0100texasmynsted(~texasmyns@99.96.221.112) (Ping timeout: 265 seconds)
2021-02-03 16:22:58 +0100 <kuribas> a is a type variable
2021-02-03 16:23:17 +0100texasmynsted_texasmynsted
2021-02-03 16:23:18 +0100 <ph88_> it's missing documentation https://hackage.haskell.org/package/mtl-2.2.2/docs/Control-Monad-Except.html#t:ExceptT
2021-02-03 16:23:23 +0100 <ph88_> only e and m have docs
2021-02-03 16:23:29 +0100 <dminuoso> Sometimes they 16:19:34 kuribas | ph88_: like I said, it doesn't matter, since you don't need state in your exceptions.
2021-02-03 16:23:32 +0100 <dminuoso> That's not the only difference
2021-02-03 16:24:09 +0100 <kuribas> dminuoso: I am talking about ph88_ 's code, not in general
2021-02-03 16:24:17 +0100 <dminuoso> Ah, okay.
2021-02-03 16:25:04 +0100 <kuribas> ph88_: why would there need to be a doc for a type variable?
2021-02-03 16:25:33 +0100 <dminuoso> So you know what the meaning of it is?
2021-02-03 16:25:39 +0100 <ph88_> obviously ?
2021-02-03 16:25:44 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl) (Ping timeout: 258 seconds)
2021-02-03 16:26:00 +0100p-core1(~Thunderbi@195.138.249.4)
2021-02-03 16:26:19 +0100 <kuribas> standard library documentation is not a tutorial on Monads, it's reference documentation.
2021-02-03 16:26:37 +0100 <dminuoso> ph88_: The `a` is your own choice. Consider:
2021-02-03 16:26:57 +0100cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 3.0)
2021-02-03 16:26:59 +0100 <dminuoso> newtype ExceptT e m a = ExceptT { runExceptT :: m (Either e a) }
2021-02-03 16:27:39 +0100p-core(~Thunderbi@2001:718:1e03:5128:3697:eeda:19aa:8e56) (Ping timeout: 258 seconds)
2021-02-03 16:27:39 +0100p-core1p-core
2021-02-03 16:27:40 +0100 <kuribas> ph88_: if you're confused about monad transformers, it may be more productive to read some tutorial or handbook.
2021-02-03 16:27:56 +0100 <dminuoso> `ExceptT E M` gives you a monad (that is, something * -> * kinded). `a` can losely be thought of as the "result type" of the monadic computation.
2021-02-03 16:28:01 +0100 <ph88_> removed pure $ Right and switched Except and State https://bpa.st/3L3A
2021-02-03 16:28:15 +0100Jd007(~Jd007@162.156.11.151)
2021-02-03 16:28:38 +0100 <kuribas> ph88_: for example: http://book.realworldhaskell.org/read/monad-transformers.html
2021-02-03 16:28:40 +0100 <ph88_> kuribas, i'm not good with books
2021-02-03 16:28:43 +0100 <dminuoso> ph88_: But really, `ExceptT` is only considered with two arguments, really.
2021-02-03 16:28:57 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 16:29:35 +0100 <dminuoso> So think of `ExceptT String IO a` as `type M = ExceptT String IO; ... M a` perhaps, so `ExceptT String M` adds a "string exception" effect to an arbitrary monad M.
2021-02-03 16:29:56 +0100 <dminuoso> Okay, I confusingly used `M` in different places there.
2021-02-03 16:30:25 +0100 <ph88_> when i look at this newtype ExceptT e m a = ExceptT { runExceptT :: m (Either e a) } i imagine m a was IO a
2021-02-03 16:30:53 +0100deviantfero(~deviantfe@190.150.27.58)
2021-02-03 16:31:15 +0100 <dminuoso> Well, let's say you want to have a base monad called `App`, you could define it as `type App = ExceptT String IO`, and then write code like `getNumber :: App Int`, then you would pick `a ~ Int`
2021-02-03 16:31:24 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 16:32:31 +0100 <dminuoso> Similarly to how `Either E` adds an exception to arbitrary computations, `ExceptT E` adds an exception effect to arbitrary effects.
2021-02-03 16:32:34 +0100nineonine(~nineonine@2604:3d08:7785:9600:acd4:a5be:3be2:2313)
2021-02-03 16:32:54 +0100 <average> so let me see if I understand this correctly
2021-02-03 16:33:47 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 256 seconds)
2021-02-03 16:36:19 +0100 <average> damn, I can't find that quote, but anyway, it was something like "Haskell is a programming language whose main purpose is writing core business logic"
2021-02-03 16:36:33 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 264 seconds)
2021-02-03 16:37:23 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2021-02-03 16:37:42 +0100 <average> to me this sounds like "We will protect the core business logic and restrict it to a very limited set of individuals through using a high-entry barrier language that has a steep learning curve"
2021-02-03 16:37:49 +0100 <average> this is how I read that
2021-02-03 16:38:03 +0100 <average> if I'm wrong, please let me know and also why
2021-02-03 16:38:08 +0100 <sshine> this one? 06:15:06 <average> "While Haskell is a general purpose language that can be used in any domain and use case, it is ideally suited for proprietary business logic and data analysis[..]"
2021-02-03 16:38:21 +0100 <average> yes exactly sshine , you found it, thanks
2021-02-03 16:38:26 +0100 <dminuoso> average: I dont agree with that assessment in any way.
2021-02-03 16:38:35 +0100 <average> dminuoso: ok, please tell me why
2021-02-03 16:38:41 +0100 <merijn> average: That's kinda the opposite of how I'd interpret it (although I don't really agree either)
2021-02-03 16:38:55 +0100 <average> merijn: that's perfectly fine. why do you disagree ?
2021-02-03 16:39:02 +0100 <dminuoso> average: Firstly, the purpose (that is what the creators intended it for), was just satisfying the creators academic curiosity.
2021-02-03 16:39:18 +0100 <dminuoso> Namely, whether a lazy pure functional programming language with a rich type system is useful.
2021-02-03 16:39:24 +0100 <dminuoso> And what you can do with it
2021-02-03 16:39:38 +0100nineonine(~nineonine@2604:3d08:7785:9600:acd4:a5be:3be2:2313) (Ping timeout: 264 seconds)
2021-02-03 16:39:40 +0100 <dminuoso> That's how it was born, anyway.
2021-02-03 16:39:53 +0100 <merijn> average: My interpretaton is: Haskell's purity and abstraction means that it's easy to create (e)DSLs for your business logic, detached from the IO/messy implementation bits to make it work
2021-02-03 16:40:00 +0100 <sshine> average, a related point is: typed, algebraic data types with records is a really neat way to express a domain model. if I have to interpret "proprietary" constructively, perhaps what's meant is: this works really well for domain models of commercial companies.
2021-02-03 16:40:03 +0100 <average> dminuoso: academia is always associated with the expression Ivory Towers, and we kindof know the direction that expression goes in https://en.wikipedia.org/wiki/Ivory_tower#Academic_usage
2021-02-03 16:40:40 +0100 <merijn> average: I also don't think Haskell is especially high barrier to entry nor has that steep a learning curve
2021-02-03 16:40:57 +0100guest23(~user@49.5.6.87) (Remote host closed the connection)
2021-02-03 16:41:10 +0100guest23(~user@49.5.6.87)
2021-02-03 16:41:21 +0100 <dminuoso> average: Right. Perhaps to some degree, the reason is that academics tend to focus on one area so well, that often (but not always) nobody except their peers understands any of what they do well enough.
2021-02-03 16:41:34 +0100 <merijn> average: Most people who know at least 1 mainstream programming language are used to new languages being basically reskins of what they already know, therefore requiring almost no effort to learn (and forgetting how hard it was to learn their first programming language originally)
2021-02-03 16:41:40 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl)
2021-02-03 16:41:49 +0100 <average> sshine: alright. and yet the reality is that, that in practice, most such systems are implemented in Java and not Haskell. And everyone who's worked for a while in companies knows that Java is prevalent
2021-02-03 16:41:50 +0100 <dminuoso> average: But I find, this sort of argument is made primarily by people who reject the notion you have to spend time studying formal methods to become good.
2021-02-03 16:42:28 +0100 <merijn> average: Haskell is hard because it's different from most mainstream languages people know, and therefore learning it feels like learning programming from scratch. But most people have forgotten how hard learning programming from scratch was
2021-02-03 16:42:44 +0100 <average> dminuoso: so Haskell requires knowledge of formal methods, which is not easy to attain. Does that not prove the high barrier for entry ?
2021-02-03 16:42:49 +0100 <dminuoso> Nope!
2021-02-03 16:42:58 +0100 <dminuoso> average: But it requires knowledge of formal methods to have invented it.
2021-02-03 16:43:00 +0100 <merijn> average: Anecdotally I have taught Haskell to a bunch of people as their first language and they didn't struggle significantly more than people I've taught, like, Java as first language
2021-02-03 16:43:09 +0100 <sshine> average, trololo :) just because Haskell is a good choice for expressing a domain model doesn't mean it has a low cost of entry, if that's all you plan to do with it.
2021-02-03 16:43:49 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl) (Remote host closed the connection)
2021-02-03 16:43:50 +0100toorevitimirp(~tooreviti@117.182.181.145) (Remote host closed the connection)
2021-02-03 16:43:50 +0100 <dminuoso> average: Haskell happens to be so clean, that it attracts many academic folks. This creates an ecosystem in which libraries arise that look complicated and/or mathy. The fact that we have complicated extensions to cater to those people doesn't help of course.
2021-02-03 16:44:03 +0100 <merijn> Actually, with my partner I'd say her experience learning Haskell was considerably easier than the Java degree/job she got afterwards
2021-02-03 16:44:15 +0100 <sshine> merijn, anecdotally: I've taught SML for a bunch of years and have always experienced that people without prior programming experience struggle less than many who have prior experience with a non-functional language. :-D
2021-02-03 16:44:28 +0100 <merijn> sshine: Same
2021-02-03 16:44:46 +0100 <merijn> I TAed functional languages in OCaml for a few years, that was always a struggle
2021-02-03 16:44:49 +0100 <dminuoso> But, admittedly, the fact that Haskell *gives* the impression of being hard to learn certainly keeps certain demographics out of its users.
2021-02-03 16:45:05 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 16:45:32 +0100toorevitimirp(~tooreviti@117.182.181.145)
2021-02-03 16:45:36 +0100 <sshine> average, bootstrapping a company with Haskell is a lot tougher than joining a company that did it already.
2021-02-03 16:45:45 +0100 <merijn> sshine: With my SO she studied Java a few months after getting through HFFP and I could just hear the sighs and facepalming as she was studying :p
2021-02-03 16:46:23 +0100 <sshine> average, only last year books started coming out about how to do this, meaning everyone who did it before that probably had a *lot* of individual trial-end-error behind them. :)
2021-02-03 16:47:33 +0100 <average> I will be very curious to know if Haskell will still be considered fit for writing core business logic once the herds of programmers start flocking around it and its user-base grows "too much"
2021-02-03 16:47:59 +0100 <merijn> Entirely unrelatedly: What's the inverse of "making clear"/"clearing up"?
2021-02-03 16:48:19 +0100 <average> my prediction is that once this happens (Haskell becoming too popular) or some time before it happens, everyone will move to some other lesser-known language that is fundamentally different from the mainstream
2021-02-03 16:48:26 +0100 <dminuoso> average: At the end of the day, what Haskell offers is utilities to avoid writing wrong code and to guide you in writing right code.
2021-02-03 16:48:29 +0100 <dolio> Obsucuring?
2021-02-03 16:48:35 +0100 <dminuoso> average: To me, this is a useful properties regardless of what kind of code you write
2021-02-03 16:48:52 +0100evanjs(~evanjs@075-129-098-007.res.spectrum.com) (Quit: ZNC 1.8.2 - https://znc.in)
2021-02-03 16:48:59 +0100 <sshine> merijn, my partner started with Python on CodinGame. there was one task that involved checking some condition the same way 8 times, and the question went something like "Isn't there some way I can do that for all of them?" and my response would be: I don't know, let's Google... yeah, "all()"! -- I think if you appeal to people's high-level way of thinking, functional programming can be a giant relief
2021-02-03 16:49:05 +0100 <sshine> before you start internalizing low-level thinking out of pure necessity because of poor libraries.
2021-02-03 16:49:23 +0100 <merijn> dolio: hmm, not quite, but that's a good place to start browsing the thesaurus from :)
2021-02-03 16:49:45 +0100 <dolio> Probably depends on the exact context of the phrase.
2021-02-03 16:49:52 +0100evanjs(~evanjs@075-129-098-007.res.spectrum.com)
2021-02-03 16:50:27 +0100michalz(~user@185.246.204.78) (Remote host closed the connection)
2021-02-03 16:50:41 +0100Foritus(~buggery@cpc91316-watf11-2-0-cust68.15-2.cable.virginm.net)
2021-02-03 16:51:13 +0100heatsink(~heatsink@2600:1700:bef1:5e10:cd3d:a18d:b2f7:b84a)
2021-02-03 16:51:23 +0100 <sshine> average, you're quite right... Haskell (and other FP research languages) tends to spawn languages, language features and libraries that are much more immediately applicable to everyone. this is a cascading effect with a much larger value than Haskell itself. but this is "Haskell the research language". there's also "Haskell the industry language". :-D
2021-02-03 16:51:46 +0100 <dminuoso> average: I dont think that Haskellers use their language out of elitism. If we had an influx of less experienced developers, I dont think that would sway developers away.
2021-02-03 16:51:50 +0100 <merijn> dolio: Something along the lines of "the datadependence of these implementations makes it unclear how to usefully compare them", but that feels very clumsy
2021-02-03 16:52:00 +0100 <merijn> I don't think that'll happen anyway
2021-02-03 16:52:01 +0100 <sshine> average, LINQ is a byproduct of FP research. LINQ is much more appreciated by quantity of programmers than Haskell. :-D
2021-02-03 16:52:16 +0100 <merijn> Haskell is in a sweet spot due to having a reasonable library ecosystem
2021-02-03 16:52:28 +0100 <merijn> I don't see, say, Idris catching up with that anytime soon
2021-02-03 16:52:49 +0100 <sshine> merijn, yep, Idris doesn't have the momentum. which is GOOD, because it can stay lean.
2021-02-03 16:52:54 +0100 <dolio> I think 'obscures' could work there, maybe. But there might be a better word.
2021-02-03 16:52:55 +0100 <dminuoso> merijn: Of course, the more unprincipled/low quality programmers join, the the more the quality on hackage degrades. :)
2021-02-03 16:53:16 +0100 <merijn> dminuoso: I mean, Hackage is already long-tailed in quality
2021-02-03 16:53:20 +0100 <merijn> Lots of junk on there
2021-02-03 16:53:43 +0100 <dminuoso> merijn: Sure, but relative to many others, Id say hackage generally has superb quality package.
2021-02-03 16:53:47 +0100 <dminuoso> That is
2021-02-03 16:54:09 +0100 <dminuoso> The percentage of high quality packages is relatively high, compared to other package/library databases of other languages.
2021-02-03 16:54:11 +0100 <merijn> I'm not sure the quality distribution of Hackage is meaningfully different from pypi
2021-02-03 16:54:24 +0100 <sshine> merijn, for all the many, many points where Haskell isn't "best in class" yet, I just have to admit that most languages I've worked with, this is equally true. e.g. in PHP, "roll your own X" is the predominant solution for *everything*.
2021-02-03 16:54:28 +0100 <merijn> Just the absolute numbers
2021-02-03 16:55:05 +0100conal(~conal@64.71.133.70) (Ping timeout: 240 seconds)
2021-02-03 16:55:12 +0100 <dminuoso> merijn: Perhaps I just happen to navigate a special subset of Hackage that is just of good quality.. but then again I audit my dependencies (transitively sometimes)
2021-02-03 16:55:16 +0100dminuososhrugs
2021-02-03 16:55:21 +0100 <dminuoso> that might skew my feelings
2021-02-03 16:55:40 +0100michalz(~user@185.246.204.76)
2021-02-03 16:55:51 +0100 <dolio> If you watch the bot, you might think differently. :)
2021-02-03 16:56:09 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2021-02-03 16:56:26 +0100heatsink(~heatsink@2600:1700:bef1:5e10:cd3d:a18d:b2f7:b84a) (Ping timeout: 264 seconds)
2021-02-03 16:56:36 +0100 <dolio> I think there are a lot of things on hackage that seem like, 'I just made a github repo, I should also upload to hackage.'
2021-02-03 16:56:52 +0100forgottenone(~forgotten@176.42.24.1)
2021-02-03 16:57:00 +0100 <average> dolio: self-promotion
2021-02-03 16:57:02 +0100 <merijn> hell
2021-02-03 16:57:05 +0100 <average> dolio: invaluable in this day and age
2021-02-03 16:57:21 +0100 <merijn> There's some package that don't even have a repo and just seem to use Hackage as version control >.>
2021-02-03 16:57:25 +0100slack1256(~slack1256@dvc-186-186-101-190.movil.vtr.net)
2021-02-03 16:57:32 +0100 <sshine> merijn, heh yeah.
2021-02-03 16:58:24 +0100ArConan(9de62a69@157.230.42.105)
2021-02-03 16:58:47 +0100raichoo(~raichoo@dslb-188-109-063-185.188.109.pools.vodafone-ip.de) (Quit: Lost terminal)
2021-02-03 16:58:51 +0100 <dolio> The stuff most people actually use is naturally way above that.
2021-02-03 16:59:45 +0100 <ski> int-e : the idea was that it's typically to be used as map `asTypeIn` \map -> map reverse "foo" .. where you repeat the name as the parameter name, and then give the expression using it
2021-02-03 16:59:46 +0100ArConan(9de62a69@157.230.42.105) (Client Quit)
2021-02-03 16:59:53 +0100 <slack1256> To use the hackage-next repository, do I need to modify the ~/.cabal/config file right? is there a way to have both allowed at the same time?
2021-02-03 17:00:24 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:8867:d061:b0e1:86b9)
2021-02-03 17:00:26 +0100forgottenone(~forgotten@176.42.24.1) (Client Quit)
2021-02-03 17:00:33 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl)
2021-02-03 17:00:36 +0100Rudd0(~Rudd0@185.189.115.103)
2021-02-03 17:00:58 +0100 <dminuoso> slack1256: Yes, you can add both
2021-02-03 17:01:42 +0100 <nshepperd> i wonder if some people upload things to hackage just because they can't figure out how to install locally developed packages otherwise
2021-02-03 17:01:43 +0100conal(~conal@66.115.157.67)
2021-02-03 17:01:45 +0100 <sshine> average, the part that makes Haskell fit for expressing core business logic isn't going to change. :) this is the least controversial part of the language and is often the part that people say "Just go back and use more of this instead of your fancy freer monananads.
2021-02-03 17:02:17 +0100 <dminuoso> slack1256: https://cabal.readthedocs.io/en/3.4/installing-packages.html#repository-specification
2021-02-03 17:02:26 +0100 <dminuoso> slack1256: Note, that if the package is on both the last one wins
2021-02-03 17:02:30 +0100 <dminuoso> (I think?)
2021-02-03 17:02:46 +0100 <average> sshine: well it would definitely be great if it someone came along to separate that part of Haskell from the rest
2021-02-03 17:02:48 +0100 <average> there is a lot of fluff
2021-02-03 17:02:49 +0100 <slack1256> dminuoso: That is exactly what I wanted to know. I will just add the common repository last.
2021-02-03 17:03:07 +0100 <merijn> slack1256: What's hackage-next?
2021-02-03 17:03:11 +0100 <average> I think I have seen many blog posts about Haskell fluff
2021-02-03 17:03:29 +0100 <average> at its peak, the Haskell fluff turns into woo-woo
2021-02-03 17:03:30 +0100deviantfero(~deviantfe@190.150.27.58) (Read error: Connection reset by peer)
2021-02-03 17:03:39 +0100 <merijn> average: So? There's lots of fluff about *any* language
2021-02-03 17:03:49 +0100 <sshine> average, you can restrict yourself to that part. this movement is called "Boring Haskell". :-D
2021-02-03 17:03:57 +0100 <merijn> This just in, 90% of Haskell blogposts are trash, because 90% of *all* blogposts are trash
2021-02-03 17:04:00 +0100 <sshine> average, https://www.snoyman.com/blog/2019/11/boring-haskell-manifesto/
2021-02-03 17:04:02 +0100 <merijn> Welcome to Sturgeon's Law
2021-02-03 17:05:00 +0100 <average> well yes, Sturgeon's Law seems applicable here, just as well as Pareto's law ..
2021-02-03 17:05:04 +0100 <merijn> sshine: I like "boring Haskell", but I dislike the "Boring Haskell" movement, since their definition of "Boring Haskell" is either to vague or too limiting to be useful
2021-02-03 17:05:12 +0100 <average> but in essence, there is some overlap betweewn Sturgeon and Pareto
2021-02-03 17:05:19 +0100 <average> except Sturgeon is a more radical view than Pareto
2021-02-03 17:05:22 +0100 <sshine> merijn, the same goes for books. I promised myself I'd never write a book. I realize I could take all my StackOverflow answers and jam them in a book of several thousands of pages, so I don't know if I implicitly broke my promise.
2021-02-03 17:05:25 +0100 <average> Pareto is more polite I think
2021-02-03 17:05:37 +0100soft-warm(4408f588@ip68-8-245-136.sd.sd.cox.net)
2021-02-03 17:05:43 +0100 <merijn> sshine: I think people should try and be minimalist about the extensions and type level stuff they adopt and make sure the ROI is good
2021-02-03 17:06:14 +0100 <merijn> sshine: But programmers *hate* "think about what you're doing and make nuanced decisions" and *love* blind adherence to dogmatic statements
2021-02-03 17:06:35 +0100 <dolio> Yeah, that will be the problem with any kind of 'movement' like that.
2021-02-03 17:07:00 +0100forgottenone(~forgotten@176.42.24.1)
2021-02-03 17:07:08 +0100deviantfero(~deviantfe@190.150.27.58)
2021-02-03 17:07:10 +0100 <sshine> merijn, I bet every concrete application of boring Haskell is slightly different. and yeah, most importantly is the incentive. :)
2021-02-03 17:07:11 +0100 <merijn> A little bit of GADTs and DataKinds can dramatically improve code where "lots of it" will make your code a painful unmaintainable mess
2021-02-03 17:07:20 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa)
2021-02-03 17:07:36 +0100 <merijn> Even type families can be "boring" IMO
2021-02-03 17:07:45 +0100 <dolio> The problem is pointlessly over-engineering, not the particular tools used to do so.
2021-02-03 17:07:51 +0100 <sshine> yeah. a bit PatternSynonym shouldn't have to complicate a module's interface, either.
2021-02-03 17:07:55 +0100 <merijn> The simple realisation is "stop trying to encode and enforce every damn thing on the type level"
2021-02-03 17:07:59 +0100 <dolio> People over-engineer in Java.
2021-02-03 17:08:40 +0100 <sshine> new DisdainingJavaStatementFactoryBuilder();
2021-02-03 17:08:45 +0100pgib(~textual@lmms/pgib) (Ping timeout: 240 seconds)
2021-02-03 17:08:50 +0100 <merijn> The only way to stop people from over-engineering is "experienced seniors thwapping people with rolled up newspapers"
2021-02-03 17:08:58 +0100 <merijn> And a sense of aesthetics
2021-02-03 17:09:18 +0100 <Logio> the bigger problem is people not being able to properly model their problems mathematically in general.
2021-02-03 17:09:57 +0100 <Logio> if you have a model of your problem, the problem of expressing it is at least well defined. otherwise you're not even wrong
2021-02-03 17:10:17 +0100kw(d4662d5d@212.102.45.93)
2021-02-03 17:10:39 +0100 <slack1256> merijn: Is another hackage repository with backpack signatures and packages. Stuff that currently hackage doesn't ship.
2021-02-03 17:10:51 +0100 <Logio> expressing it in Haskell (or other programming language) I mean
2021-02-03 17:11:55 +0100 <tdammers> and then there's also the whole agenda thing (i.e., pushing for a particular dogma because it suits your business case)
2021-02-03 17:12:07 +0100pzzl(~pzzl@eimer.scc.uni-weimar.de) (Quit: Leaving)
2021-02-03 17:12:20 +0100 <sshine> merijn, it seems like an art form. when I showed my gf my Haskell version of that introductory programming problem, my first reaction was to define two helper functions with meaningful names, and then the problem became a one-liner. it was one of those cases where my brain has done too much of this, and that if you plot 1000 people's solutions, you'd get all kinds of variations of short/long,
2021-02-03 17:12:26 +0100 <sshine> verbose/concise, readable/cryptic, and I just always go for most readable and fewest edge cases, or something like that...
2021-02-03 17:13:07 +0100p-core(~Thunderbi@195.138.249.4) (Read error: Connection reset by peer)
2021-02-03 17:13:24 +0100 <slack1256> (how great having your GF also know haskell :-) )
2021-02-03 17:13:35 +0100 <sshine> but "most readable" is still point-free, applicative. I don't know why that is so appealing.
2021-02-03 17:13:39 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa) (Ping timeout: 258 seconds)
2021-02-03 17:13:49 +0100 <sshine> slack1256, my gf doesn't know Haskell. she's just learning Python because she is unemployed right now. ;)
2021-02-03 17:14:35 +0100 <merijn> slack1256: That's easy
2021-02-03 17:14:45 +0100 <slack1256> sshine: Nice, I am doing kind of the same.
2021-02-03 17:15:05 +0100 <sshine> slack1256, learning programming while unemployed?
2021-02-03 17:15:13 +0100 <merijn> slack1256: Step 1) get a partner, Haskell knowledge optional, Step 2) teach Haskell if not yet known :p
2021-02-03 17:15:33 +0100 <slack1256> merijn: Well she has to have a natural interest in the first place for that to work.
2021-02-03 17:16:04 +0100 <merijn> Some things are dealbreakers :p
2021-02-03 17:16:05 +0100 <slack1256> But she liked 3d printing and fusion 360. That program can be scripted, so through there I started teaching her python.
2021-02-03 17:16:30 +0100 <slack1256> sshine: Not unemployed but certainly under-employed. Well me too.
2021-02-03 17:18:15 +0100 <average> sshine: re "take all my SO answers and jam them in a book of several thousand pages" . I do that here, but it's not a book.. just a repo https://github.com/wsdookadr/so/
2021-02-03 17:18:40 +0100 <average> sshine: this is my SO https://stackoverflow.com/users/827519/wsdookadr
2021-02-03 17:18:53 +0100cfricke(~cfricke@unaffiliated/cfricke)
2021-02-03 17:20:14 +0100ichimaru(~ichimaru@45.63.97.131) (Quit: ichimaru)
2021-02-03 17:20:16 +0100plutoniix(~q@node-unx.pool-125-24.dynamic.totinternet.net)
2021-02-03 17:20:26 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Remote host closed the connection)
2021-02-03 17:20:29 +0100 <sshine> average, that's pretty neat. :)
2021-02-03 17:21:13 +0100 <ski> a book is presumably more/different, than a collection of short, probably quite informal (and disconnected), pieces
2021-02-03 17:21:53 +0100 <merijn> ski: pigworker disagrees ;)
2021-02-03 17:21:54 +0100Foritus(~buggery@cpc91316-watf11-2-0-cust68.15-2.cable.virginm.net) (Quit: ლ(ಠ益ಠლ) .:. <Ashley> my porn is hidden in a folder called "BBC Micro Emulator")
2021-02-03 17:22:04 +0100 <ski> heh :)
2021-02-03 17:22:13 +0100 <dolio> He does?
2021-02-03 17:22:15 +0100 <merijn> ski: https://personal.cis.strath.ac.uk/conor.mcbride/so-pigworker.pdf
2021-02-03 17:22:18 +0100 <merijn> dolio: ^^
2021-02-03 17:22:47 +0100Foritus(~buggery@cpc91316-watf11-2-0-cust68.15-2.cable.virginm.net)
2021-02-03 17:25:01 +0100 <ski> there's certainly some books which are more a collection of short articles (e.g. "The Fun of Programming", where each chapter is by a different person)
2021-02-03 17:25:11 +0100 <exarkun> https://hackage.haskell.org/package/binary-0.8.7.0/docs/Data-Binary-Get.html#v:runGet says it returns `a` and `stack ls dependencies` says "binary 0.8.7.0" but when I declare that "readVersion share = runGet getWord32be share" has type "B.ByteString -> Word32" then ghc says: Couldn't match expected type ‘Word32’ with actual type ‘Either String Word32’
2021-02-03 17:25:13 +0100heatsink(~heatsink@2600:1700:bef1:5e10:cd3d:a18d:b2f7:b84a)
2021-02-03 17:25:35 +0100 <exarkun> I don't understand
2021-02-03 17:25:39 +0100 <ski> but in that case, there's some kind of common (perhaps a bit nebulous) theme, still
2021-02-03 17:25:41 +0100 <dolio> Yeah. I guess the connotation was some kind of text book.
2021-02-03 17:26:04 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-03 17:26:41 +0100 <merijn> exarkun: What's the type of "share"?
2021-02-03 17:26:47 +0100 <merijn> And what's the type of readVersion?
2021-02-03 17:26:50 +0100 <ski> merijn : looks like it might be fun, ty :)
2021-02-03 17:27:07 +0100 <exarkun> Oh hell I'm using runGet from Data.Serialize instead of Data.Binary.Get
2021-02-03 17:27:16 +0100 <merijn> exarkun: hah
2021-02-03 17:27:51 +0100 <exarkun> ty for your indulgence
2021-02-03 17:27:59 +0100 <merijn> exarkun: Although you should probably use runGetOrFail instead :p
2021-02-03 17:28:42 +0100 <exarkun> probably, though this is in a test suite
2021-02-03 17:29:49 +0100 <exarkun> heh, and now head is failing before runGet ever gets a chance...
2021-02-03 17:32:14 +0100toorevitimirp(~tooreviti@117.182.181.145) (Remote host closed the connection)
2021-02-03 17:33:41 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net) (Read error: Connection reset by peer)
2021-02-03 17:34:31 +0100Narinas(~Narinas@189.223.62.254.dsl.dyn.telnor.net)
2021-02-03 17:39:43 +0100slack1256(~slack1256@dvc-186-186-101-190.movil.vtr.net) (Remote host closed the connection)
2021-02-03 17:40:01 +0100skiread that as "head is falling"
2021-02-03 17:41:27 +0100igghibu(~igghibu@37.120.201.121)
2021-02-03 17:42:54 +0100rcdilorenzo(~rcdiloren@62.182.99.136) (Ping timeout: 265 seconds)
2021-02-03 17:44:25 +0100catt(~r@31.124.181.226) (Ping timeout: 240 seconds)
2021-02-03 17:44:26 +0100 <sm[m]> g'day all. Failing to do something simple in ghci:
2021-02-03 17:44:26 +0100 <sm[m]> parseTimeM True defaultTimeLocale "%Y-%m-%dT%s%Q%Z" "2021-02-03T000247.0581Z"
2021-02-03 17:44:26 +0100 <sm[m]> This has type (MonadFail m, ParseTime t) => m t, how would you make it showable ?
2021-02-03 17:44:27 +0100 <maerwald> merijn: you think teaching haskell is fun? (or teaching at all)
2021-02-03 17:44:37 +0100nineonine(~nineonine@2604:3d08:7785:9600:acd4:a5be:3be2:2313)
2021-02-03 17:44:52 +0100danza(~francesco@151.53.69.219) (Quit: Leaving)
2021-02-03 17:45:21 +0100frozenErebus(~frozenEre@37.231.239.43) (Ping timeout: 246 seconds)
2021-02-03 17:45:24 +0100 <maerwald> sm[m]: use the MonadFail Maybe instance?
2021-02-03 17:45:49 +0100 <sm[m]> I've been trying..
2021-02-03 17:45:53 +0100rcdilorenzo(~rcdiloren@62.182.99.136)
2021-02-03 17:46:03 +0100nineonine(~nineonine@2604:3d08:7785:9600:acd4:a5be:3be2:2313) (Remote host closed the connection)
2021-02-03 17:46:09 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 264 seconds)
2021-02-03 17:46:19 +0100mmohammadi9812(~mmohammad@2.178.213.79) (Read error: Connection reset by peer)
2021-02-03 17:46:31 +0100mmohammadi9812(~mmohammad@198.12.95.182)
2021-02-03 17:47:05 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa)
2021-02-03 17:47:07 +0100 <sm[m]> ah finally.. fromJust $ parseTimeM True defaultTimeLocale "%Y-%m-%dT%s%Q%Z" "2021-02-03T000247.0581Z" :: UTCTime . Thanks!
2021-02-03 17:47:10 +0100brandonhamilton(~brandonha@2a04:3542:1000:910:905f:f9ff:fe67:4d32)
2021-02-03 17:47:47 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-03 17:48:02 +0100 <maerwald> sm[m]: or: parseTimeM @Maybe @UTCTime True defaultTimeLocale "%Y-%m-%dT%s%Q%Z" "2021-02-03T000247.0581Z"
2021-02-03 17:48:32 +0100 <sm[m]> interesting
2021-02-03 17:49:48 +0100 <sm[m]> haskell keeps.. changing :)
2021-02-03 17:50:03 +0100cfricke(~cfricke@unaffiliated/cfricke) (Quit: WeeChat 3.0)
2021-02-03 17:50:51 +0100 <maerwald> TypeApplications is there since 8.0.1
2021-02-03 17:51:07 +0100 <sm[m]> ghci> :t parseTimeM :: (MonadFail m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
2021-02-03 17:51:07 +0100 <sm[m]> ghci> :t parseTimeM @Maybe @UTCTime :: Bool -> TimeLocale -> String -> String -> Maybe UTCTime
2021-02-03 17:51:36 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa) (Ping timeout: 258 seconds)
2021-02-03 17:51:59 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 17:52:02 +0100 <sm[m]> still quite new to most haskellers I think
2021-02-03 17:52:05 +0100elfets(~elfets@ip-37-201-23-96.hsi13.unitymediagroup.de)
2021-02-03 17:53:40 +0100 <sm[m]> https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#extension-TypeAp…
2021-02-03 17:53:43 +0100polyphem(~p0lyph3m@2a02:810d:640:776c:76d7:55f6:f85b:c889)
2021-02-03 17:54:09 +0100 <swarmcollective> :t parseTimeM @Maybe @UTCTime
2021-02-03 17:54:11 +0100 <lambdabot> error:
2021-02-03 17:54:11 +0100 <lambdabot> Pattern syntax in expression context: parseTimeM@Maybe
2021-02-03 17:54:11 +0100 <lambdabot> Did you mean to enable TypeApplications?
2021-02-03 17:54:21 +0100 <swarmcollective> Interesting.
2021-02-03 17:54:34 +0100 <c_wraith> Nah. "new" is -XImpredicativeTypes working. and by "new" I mean "not technically released yet"
2021-02-03 17:54:40 +0100 <sm[m]> I see.. the @'s are simply used to fill in type variables in the type signature, from left to right
2021-02-03 17:54:57 +0100 <sm[m]> (of the thing to the left of them)
2021-02-03 17:55:03 +0100 <maerwald> sm[m]: hmm, not always left to right, I always forget the exact rules
2021-02-03 17:55:08 +0100 <maerwald> unless there is a forall
2021-02-03 17:55:13 +0100 <c_wraith> It's always left to right
2021-02-03 17:55:28 +0100 <maerwald> c_wraith: let me find the counter-example then
2021-02-03 17:55:35 +0100 <c_wraith> it's just that a forall clause is considered the first use of the variable, if it's present
2021-02-03 17:55:41 +0100 <sm[m]> oh yikes, this doc section is much longer than I thought
2021-02-03 17:56:51 +0100igghibu(~igghibu@37.120.201.121) (Quit: Textual IRC Client: www.textualapp.com)
2021-02-03 17:57:12 +0100hnOsmium0001(uid453710@gateway/web/irccloud.com/x-vcqnqeayruwjdhxh)
2021-02-03 17:59:40 +0100ep1ctetus(~epictetus@ip184-187-162-163.sb.sd.cox.net)
2021-02-03 18:00:33 +0100kupi(uid212005@gateway/web/irccloud.com/x-qetuytxtunbuqszx)
2021-02-03 18:00:52 +0100 <merijn> maerwald: I like teaching, so yes
2021-02-03 18:00:57 +0100 <kuribas> sshine: I don't think conciseness is a good metric, however if you stick to the stuff that matters, and eliminate cruft, you usually do end up with less code.
2021-02-03 18:01:25 +0100 <merijn> c_wraith: It's not that ImpredicativeTypes works, it's that we can actually *tell* if it works now :p
2021-02-03 18:01:29 +0100 <kuribas> but actively trying to make code more concise will end up with unreadable code.
2021-02-03 18:01:41 +0100 <sm[m]> "If any of the variables depend on other variables (that is, if some of the variables are kind variables), the variables are reordered so that kind variables come before type variables, preserving the left-to-right order as much as possible."
2021-02-03 18:01:53 +0100 <maerwald> ah
2021-02-03 18:02:11 +0100 <merijn> maerwald, sm[m]: I strongly oppose the use of TypeApplication in "real" code as it's incredibly brittle
2021-02-03 18:02:48 +0100 <merijn> Using it means you are making something part of upstream's public API that is normally *not* considered part of the API and thus no care is taken not to break it
2021-02-03 18:03:03 +0100 <c_wraith> merijn: nah, it's that it actually works. There are lots of places before you could enable it and it wouldn't reject things as a syntax error, but it would give you a type error like cannot match (forall b. b-> b) with (forall b. b -> b)
2021-02-03 18:03:24 +0100 <sm[m]> and @_ can be used as a wildcard placeholder
2021-02-03 18:03:27 +0100 <merijn> c_wraith: How would you even tell whether it worked before? Nobody had a specification of what it meant :p
2021-02-03 18:03:40 +0100 <monochrom> My code is short, but it's a side effect not an objective. My objective is eliminating XY problems.
2021-02-03 18:03:43 +0100 <sm[m]> merijn: noted
2021-02-03 18:03:55 +0100geekosaur(82650c7c@130.101.12.124)
2021-02-03 18:04:07 +0100ubert(~Thunderbi@2a02:8109:9880:303c:54a5:5901:5ae5:e9e0) (Remote host closed the connection)
2021-02-03 18:04:08 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa)
2021-02-03 18:04:22 +0100 <c_wraith> merijn: well, "working" would definitely include "doesn't produce errors saying identical types don't match"
2021-02-03 18:04:22 +0100 <sm[m]> I guess if I dug into ghc dev history I'd find the rationale for it
2021-02-03 18:04:26 +0100 <merijn> maerwald, sm[m]: There has *already* been a change in GHC's type inference that changed the order in which type variables were inferred in the forall clause, meaning that uses of TypeApplications on functions with no explicit forall broke
2021-02-03 18:04:58 +0100 <maerwald> yeah and I remember an example where it wasn't left to right and pretty confusing
2021-02-03 18:05:01 +0100 <maerwald> can't find it anymore
2021-02-03 18:05:13 +0100 <merijn> And if someone adds an explicit forall (say, to use ScopedTypeVariables) and writes out their type variables differently from GHCs order, that also breaks
2021-02-03 18:05:49 +0100 <merijn> The number of people (even hardcore PVP adherents) that account for that as part of their public API is probably roughly zero
2021-02-03 18:05:53 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa) (Remote host closed the connection)
2021-02-03 18:06:30 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa)
2021-02-03 18:06:55 +0100 <merijn> So unless you use exact versions for all your dependencies that's potential breakage, but exact versions for dependencies is nightmare of bounds maintenance
2021-02-03 18:07:19 +0100conal(~conal@66.115.157.67) (Ping timeout: 258 seconds)
2021-02-03 18:07:37 +0100 <ski> kuribas : hm, i guess conciseness is often a kind of happy accidental side-effect of striving to make code better, but not a goal one should aim directly at
2021-02-03 18:07:50 +0100pavonia(~user@unaffiliated/siracusa) (Quit: Bye!)
2021-02-03 18:09:19 +0100 <ski> (at least we're not letting uses of polymorphic values depend on the *names* used for the tyvars in the type signature .. unlike some other language)
2021-02-03 18:09:52 +0100 <kuribas> which other language?
2021-02-03 18:10:03 +0100 <monochrom> Haskell itself already causes a lot of conciseness just because it's so bloody high-level. For example you just write "Ctor x y" not "new Ctor x y" compared to Java and Rust. That already cuts down length by 30-50%.
2021-02-03 18:10:37 +0100 <kuribas> and the tendency to write short function names and short variables, which isn't always good IMO...
2021-02-03 18:11:46 +0100ryantrinkle(~ryan@cpe-24-168-87-184.si.res.rr.com)
2021-02-03 18:12:07 +0100 <c_wraith> I still don't know why theValueIDon'tKnowAnythingAbout is a better variable name than x
2021-02-03 18:12:17 +0100conal(~conal@64.71.133.70)
2021-02-03 18:12:31 +0100 <maerwald> you type less
2021-02-03 18:12:36 +0100 <monochrom> This is why I say that "meaningful name" is a religion.
2021-02-03 18:12:37 +0100 <merijn> Length/descriptiveness of name should depend on two factors
2021-02-03 18:12:50 +0100 <c_wraith> maerwald: I think you may have read that backwards
2021-02-03 18:12:53 +0100 <merijn> 1) scope, the bigger the scope, the more descriptive the name should be
2021-02-03 18:12:57 +0100 <maerwald> when you have RSI, you stop caring about clear variable names :)
2021-02-03 18:13:14 +0100 <kuribas> c_wraith: it isn't
2021-02-03 18:13:20 +0100 <merijn> 2) frequency of use, less frequently used names should be more descriptive
2021-02-03 18:13:23 +0100 <c_wraith> but people tell me it is!
2021-02-03 18:13:25 +0100 <maerwald> c_wraith: wasn't a response to your sentence
2021-02-03 18:13:25 +0100 <c_wraith> constantly!
2021-02-03 18:13:33 +0100 <c_wraith> maerwald: oh, oops. sorry
2021-02-03 18:13:58 +0100 <maerwald> I cut down the chars here as well...
2021-02-03 18:14:11 +0100 <kuribas> merijn: indeed, I am more bother by badly named exported functions than by badly named local variables.
2021-02-03 18:15:23 +0100skiseconds merijn
2021-02-03 18:15:48 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 246 seconds)
2021-02-03 18:15:57 +0100 <maerwald> merijn: my favorite is "removeFile"... is it descriptive? :)
2021-02-03 18:16:57 +0100carlomagno(~cararell@148.87.23.7) (Remote host closed the connection)
2021-02-03 18:16:59 +0100 <maerwald> I'd argue not much more than "unlink"
2021-02-03 18:17:12 +0100 <maerwald> you'll end up reading the documentation regardless
2021-02-03 18:17:31 +0100 <maerwald> and then still forget half of it when using it and get confused later
2021-02-03 18:17:35 +0100 <geekosaur> its behavior depends on the platform, too
2021-02-03 18:18:18 +0100bitmagie(~Thunderbi@200116b806108700484948e27a931f58.dip.versatel-1u1.de)
2021-02-03 18:18:22 +0100carlomagno(~cararell@148.87.23.7)
2021-02-03 18:18:40 +0100bitmagie(~Thunderbi@200116b806108700484948e27a931f58.dip.versatel-1u1.de) (Client Quit)
2021-02-03 18:19:20 +0100coot(~coot@37.30.55.141.nat.umts.dynamic.t-mobile.pl) (Quit: coot)
2021-02-03 18:20:08 +0100 <maerwald> so here's a poor counter-thought: do unclear names force ppl to read the documentation?
2021-02-03 18:20:22 +0100Saukk(~Saukk@83-148-239-3.dynamic.lounea.fi)
2021-02-03 18:20:36 +0100rcdilorenzo(~rcdiloren@62.182.99.136) (Ping timeout: 240 seconds)
2021-02-03 18:20:44 +0100 <dolio> If it does, that's not a good argument in their favor.
2021-02-03 18:20:46 +0100 <maerwald> I surely read the whole manpage when I first saw "unlink", because what the hell
2021-02-03 18:20:47 +0100 <geekosaur> they force people to google
2021-02-03 18:21:01 +0100 <geekosaur> people will do anything before resorting to documentation
2021-02-03 18:21:07 +0100brandonhamilton(~brandonha@2a04:3542:1000:910:905f:f9ff:fe67:4d32) (Ping timeout: 258 seconds)
2021-02-03 18:21:07 +0100frozenErebus(~frozenEre@37.231.239.43)
2021-02-03 18:22:43 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-03 18:23:14 +0100 <maerwald> geekosaur: well, documentation is often trash, but we'll never know if that started, because no one reads it or no one reads it, because it's trash
2021-02-03 18:23:30 +0100nineonin_(~nineonine@50.216.62.2)
2021-02-03 18:23:49 +0100 <maerwald> I'd argue that search engines made documentation worse, though
2021-02-03 18:23:58 +0100skiidly wonders whether there's a stated law about the lengths people will go to, to avoid looking into docs
2021-02-03 18:24:27 +0100 <swarmcollective> <opinion> Haskell library documentation would be greatly improved with some examples. Doctest samples would work well for this.
2021-02-03 18:25:06 +0100swarmcollectivewould like to find time to update some of the docs.
2021-02-03 18:25:43 +0100 <maerwald> https://hackage.haskell.org/package/directory-1.3.6.1/docs/System-Directory.html#v:removeFile I can't even figure out if it follows symlinks
2021-02-03 18:25:45 +0100 <aveltras> examples is clearly the most important thing lacking when trying to use some libraries
2021-02-03 18:26:17 +0100nineonine(~nineonine@2604:3d08:7785:9600:95c8:88e9:a60d:8dfa) (Ping timeout: 260 seconds)
2021-02-03 18:27:00 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 18:30:03 +0100 <aveltras> im porting some oo code and wondering if there is a better way to accomplish the following. I have an InlineNotification class with many fields and a ToastNotification class which extends it adding one field. The obvious way to port it (and how i do it for now) is to have an InlineNotification record and a ToastNotification with an _inlineNotification field in it. But then the problem is that whenever you want to
2021-02-03 18:30:03 +0100 <aveltras> access the inner fields for the toast notification, you have to dig through the "_inlineNotification" field, which you don't have to do in oop lang. Is there another approach to this ?
2021-02-03 18:30:29 +0100 <koz_> aveltras: You can use lenses which make this a bit less awkward.
2021-02-03 18:30:45 +0100 <aveltras> im using lenses already
2021-02-03 18:30:50 +0100Ariakenom(~Ariakenom@2001:9b1:efb:fc00:6006:2ad2:8fc2:e1e4)
2021-02-03 18:30:50 +0100 <enikar> maerwald: I think, i don't follow symlink, because the doc says « removes a directory entry », but is it true?
2021-02-03 18:31:16 +0100 <aveltras> but i still have to use the intermediary lense (or at least i think so using makeLenses TH)
2021-02-03 18:31:30 +0100 <geekosaur> but you can define your own composed lenses to hide it
2021-02-03 18:31:32 +0100 <koz_> aveltras: Then that's pretty much it. If you wanna do OOP stuff, Haskell's not the language - you can't port the same idea of 'extending' stuff directly without awkwardness.
2021-02-03 18:31:37 +0100 <koz_> What geekosaur said.
2021-02-03 18:32:32 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 18:32:38 +0100 <maerwald> enikar: it doesn't follow them
2021-02-03 18:33:10 +0100pera(~pera@unaffiliated/pera) (Ping timeout: 265 seconds)
2021-02-03 18:33:11 +0100 <maerwald> enikar: any proper manpage (e.g. of `unlink`) says explicitly what happens with symlinks
2021-02-03 18:34:02 +0100 <maerwald> but then again, this is a cross platform lib and there's even a (poor) hint about a major complication on windows, that most ppl won't be able to infer, unless they already know it
2021-02-03 18:34:03 +0100 <enikar> maerwald: nice, I guess the correct behaviour, but this is just a happy luck…
2021-02-03 18:35:29 +0100rajivr(uid269651@gateway/web/irccloud.com/x-rezdfhgnedgqggyb) (Quit: Connection closed for inactivity)
2021-02-03 18:36:33 +0100knupfer(~Thunderbi@200116b82c27b900ad15eb691b6438af.dip.versatel-1u1.de) (Remote host closed the connection)
2021-02-03 18:36:39 +0100 <aveltras> i'll do custom lenses then i think, not sure i can get those with TH easily
2021-02-03 18:36:58 +0100knupfer(~Thunderbi@200116b82c27b900392e02b43800d436.dip.versatel-1u1.de)
2021-02-03 18:37:05 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 240 seconds)
2021-02-03 18:37:14 +0100Yumasi(~guillaume@2a01:e0a:5cb:4430:572d:5f36:41d6:1475) (Ping timeout: 264 seconds)
2021-02-03 18:38:00 +0100mastarija(~mastarija@188.252.197.178)
2021-02-03 18:38:08 +0100 <enikar> maerwald: I'm agree with you, this documentation has a lack…
2021-02-03 18:40:56 +0100rcdilorenzo(~rcdiloren@cpe-76-182-87-188.nc.res.rr.com)
2021-02-03 18:42:33 +0100 <maerwald> so my claim is this: names don't have to be accurate, just memorable
2021-02-03 18:45:19 +0100 <maerwald> `cutTree` for recursive directory removal is ok imo
2021-02-03 18:51:00 +0100 <ski> it can help, at times, if names don't evoke previous (irrelevant or even countering) associations
2021-02-03 18:52:16 +0100geekosaur(82650c7c@130.101.12.124) (Quit: Ping timeout (120 seconds))
2021-02-03 18:52:23 +0100soft-warm(4408f588@ip68-8-245-136.sd.sd.cox.net) (Quit: Connection closed)
2021-02-03 18:53:18 +0100chele(~chele@ip5b40237d.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2021-02-03 18:53:53 +0100 <monochrom> My criteria for names is mnemonics and hamming distance. Length and "meaning" are side effects.
2021-02-03 18:54:08 +0100 <monochrom> s/ is / are / # I hate English
2021-02-03 18:54:33 +0100 <shapr> Has anyone used the cookie functionality in http-client?
2021-02-03 18:54:45 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-03 18:54:52 +0100 <shapr> If yes, what's the right way to thread cookies through multiple requests?
2021-02-03 18:54:52 +0100geekosaur(82650c7c@130.101.12.124)
2021-02-03 18:55:11 +0100 <shapr> My code logs into a server, I get an auth cookie in return.
2021-02-03 18:55:50 +0100 <shapr> I'd like to correctly thread the cookies from each response through each request to the server after that.
2021-02-03 18:55:51 +0100f-a(~f-a@151.34.30.157)
2021-02-03 18:56:19 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 18:56:44 +0100 <maerwald> https://hackage.haskell.org/package/http-client-0.7.4/docs/Network-HTTP-Client.html#v:managerModif… and then share the manager across requests (which you should do anyway)?
2021-02-03 18:57:18 +0100hseg(~gesh@185.120.124.95)
2021-02-03 18:58:37 +0100 <hseg> hi. am packaging up some haskell programs, is there a way to tell stack to cache package archives somewhere outside of the build directory?
2021-02-03 18:58:59 +0100 <hseg> eg i see it's taking a while to download https://s3.amazonaws.com/hackage.fpcomplete.com/package/pandoc-2.11.4.tar.gz
2021-02-03 18:58:59 +0100pera(~pera@unaffiliated/pera)
2021-02-03 18:59:04 +0100 <maerwald> hseg: https://github.com/fpco/cache-s3
2021-02-03 18:59:35 +0100 <hseg> meant caching locally
2021-02-03 19:00:07 +0100 <hseg> so e.g. having ~/.local/var/cache/stack/sources/... that contains the source tarballs
2021-02-03 19:00:26 +0100 <hseg> and then download the tarballs stack needs myself (eg with aria2)
2021-02-03 19:00:38 +0100 <hseg> so that it doesn't need to do so every time
2021-02-03 19:00:57 +0100 <hseg> especially if the dependencies change much more slowly than the package
2021-02-03 19:01:18 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 246 seconds)
2021-02-03 19:02:05 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 19:02:17 +0100kw(d4662d5d@212.102.45.93) (Quit: Connection closed)
2021-02-03 19:03:34 +0100dyeplexer(~lol@unaffiliated/terpin) (Remote host closed the connection)
2021-02-03 19:04:39 +0100 <hseg> hrm. looking at stack's fds, it is looking at something called pantry.sqlite3?
2021-02-03 19:04:45 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 240 seconds)
2021-02-03 19:04:48 +0100Foritus(~buggery@cpc91316-watf11-2-0-cust68.15-2.cable.virginm.net) (Ping timeout: 246 seconds)
2021-02-03 19:06:11 +0100frozenErebus(~frozenEre@37.231.239.43) (Ping timeout: 272 seconds)
2021-02-03 19:07:05 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-03 19:07:28 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 272 seconds)
2021-02-03 19:07:49 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 19:08:37 +0100philopsos(~caecilius@gateway/tor-sasl/caecilius)
2021-02-03 19:10:19 +0100 <hseg> stack is taking much longer than aria2 to download the pandoc tarball, is there any way I can just drop the tarball in the right location?
2021-02-03 19:10:33 +0100p-core(~Thunderbi@2001:718:1e03:5128:3697:eeda:19aa:8e56)
2021-02-03 19:10:58 +0100 <shapr> maerwald: I don't see any code in http-client where a manager handles cookie updating, is there such a thing?
2021-02-03 19:11:27 +0100rcdilorenzo_(~rcdiloren@cpe-76-182-87-188.nc.res.rr.com)
2021-02-03 19:11:33 +0100 <maerwald> don't think so, it's all about the Ruqeust type afais
2021-02-03 19:11:36 +0100 <texasmynsted> If I have a lazy ByteString with escapes like \n \t, how to I print so that \n becomes newline?
2021-02-03 19:11:54 +0100Major_Biscuit(~Major_Bis@82.169.100.198) (Ping timeout: 272 seconds)
2021-02-03 19:12:05 +0100rcdilorenzo(~rcdiloren@cpe-76-182-87-188.nc.res.rr.com) (Ping timeout: 240 seconds)
2021-02-03 19:12:10 +0100 <texasmynsted> When I print the ByteString directly I see \n in the output. This makes sense.
2021-02-03 19:12:56 +0100 <maerwald> shapr: but there is `mModifyRequest :: Request -> IO Request`
2021-02-03 19:13:10 +0100 <maerwald> I just can't see currently how to set it...
2021-02-03 19:13:14 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Remote host closed the connection)
2021-02-03 19:13:15 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 258 seconds)
2021-02-03 19:13:18 +0100 <maerwald> https://hackage.haskell.org/package/http-client-0.7.4/docs/src/Network.HTTP.Client.Types.html#Mana…
2021-02-03 19:13:24 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 19:13:48 +0100dnlkrgr(~dnlkrgr@HSI-KBW-046-005-005-235.hsi8.kabel-badenwuerttemberg.de)
2021-02-03 19:13:52 +0100Saukk(~Saukk@83-148-239-3.dynamic.lounea.fi) (Remote host closed the connection)
2021-02-03 19:14:51 +0100 <geekosaur> texasmynsted, first make sure there's no "show" involved anywhere.
2021-02-03 19:15:22 +0100 <texasmynsted> well show is.
2021-02-03 19:15:30 +0100 <geekosaur> beyond that, you may need to add double quotes and take a trip through read, or use a string parser (I don't think there's any predefined beyond the Read instance)
2021-02-03 19:15:38 +0100rcdilorenzo_(~rcdiloren@cpe-76-182-87-188.nc.res.rr.com) (Client Quit)
2021-02-03 19:15:41 +0100 <geekosaur> show converts actual control characters to escapes
2021-02-03 19:15:46 +0100 <maerwald> shapr: maybe: defaultManagerSettings { managerModifyRequest = ... }
2021-02-03 19:15:50 +0100 <geekosaur> if you don't want that, don't use show
2021-02-03 19:15:52 +0100rcdilorenzo(~rcdiloren@cpe-76-182-87-188.nc.res.rr.com)
2021-02-03 19:16:17 +0100 <geekosaur> > show "\tabc"
2021-02-03 19:16:19 +0100 <lambdabot> "\"\\tabc\""
2021-02-03 19:16:34 +0100 <shapr> maerwald: ah, you think a function could be supplied to update cookies?
2021-02-03 19:16:46 +0100 <geekosaur> wait
2021-02-03 19:16:49 +0100 <geekosaur> "\tabc"
2021-02-03 19:16:52 +0100 <maerwald> yeah, the cookie would be "hidden" in the partially applied function
2021-02-03 19:16:56 +0100 <texasmynsted> I think it is happening automatically
2021-02-03 19:16:59 +0100 <geekosaur> it's already doing show in lb
2021-02-03 19:17:03 +0100 <geekosaur> > text "\tabc"
2021-02-03 19:17:05 +0100 <lambdabot> abc
2021-02-03 19:17:11 +0100 <geekosaur> (text is speific to lambdabot)
2021-02-03 19:17:16 +0100jluttine(~jluttine@85-23-95-149.bb.dnainternet.fi)
2021-02-03 19:18:16 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-02-03 19:18:34 +0100 <hseg> hrm, lsof suggests stack downloads archives to temporary directories
2021-02-03 19:18:34 +0100 <texasmynsted> say I have a bytestring foo
2021-02-03 19:18:38 +0100 <texasmynsted> print foo
2021-02-03 19:18:54 +0100 <hseg> any way of giving it an already-downloaded tarball
2021-02-03 19:18:55 +0100 <hseg> ?
2021-02-03 19:19:04 +0100 <texasmynsted> also print (foo :: ByteString)
2021-02-03 19:19:06 +0100f-a(~f-a@151.34.30.157) ()
2021-02-03 19:19:08 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 19:19:23 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-03 19:19:48 +0100 <geekosaur> texasmynsted, why use print at all? it's just putStrLn . show
2021-02-03 19:19:56 +0100mastarija(~mastarija@188.252.197.178) (Quit: Leaving)
2021-02-03 19:19:59 +0100 <geekosaur> so use putStrLn directly if you don't want the show
2021-02-03 19:20:08 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 272 seconds)
2021-02-03 19:20:09 +0100 <texasmynsted> heh, I thought that putStrLn used show
2021-02-03 19:21:12 +0100soft-warm(4408f588@ip68-8-245-136.sd.sd.cox.net)
2021-02-03 19:21:15 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net) (Ping timeout: 246 seconds)
2021-02-03 19:21:22 +0100 <texasmynsted> hmm putStrLn expects String not ByteString
2021-02-03 19:21:43 +0100Deide(~Deide@217.155.19.23)
2021-02-03 19:22:04 +0100 <hseg> why on earth does 'stack path' require 'stack setup'?
2021-02-03 19:22:11 +0100pera(~pera@unaffiliated/pera) (Quit: leaving)
2021-02-03 19:22:32 +0100 <hseg> all i want is to know where to drop the tarball stack is taking ages to download
2021-02-03 19:22:57 +0100 <shapr> hseg: Are you the person who makes math art?
2021-02-03 19:22:58 +0100Tario(~Tario@201.192.165.173) (Read error: Connection reset by peer)
2021-02-03 19:23:01 +0100 <geekosaur> so BS.unpack it (probably using .Char8, which is safe in this direction if less than ideal depending on the encoding embedded in the ByteString)
2021-02-03 19:23:28 +0100 <hseg> what math art? you mean byorgey's blog?
2021-02-03 19:23:42 +0100jluttine(~jluttine@85-23-95-149.bb.dnainternet.fi) (Ping timeout: 246 seconds)
2021-02-03 19:23:42 +0100 <shapr> ah, never mind
2021-02-03 19:23:44 +0100Foritus(~buggery@cpc91316-watf11-2-0-cust68.15-2.cable.virginm.net)
2021-02-03 19:23:52 +0100Tario(~Tario@201.192.165.173)
2021-02-03 19:24:24 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 246 seconds)
2021-02-03 19:24:32 +0100 <hseg> am doing some computer algebra in haskell, though
2021-02-03 19:24:54 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-02-03 19:25:00 +0100 <geekosaur> show is an easy way to make something a String, at a price since it does things like turning anything that's not in the ord range 32-126 to an escape. You have to decide what you want done with anything not in that range if you want to do it without show
2021-02-03 19:25:17 +0100dnlkrgr(~dnlkrgr@HSI-KBW-046-005-005-235.hsi8.kabel-badenwuerttemberg.de) (Read error: Connection reset by peer)
2021-02-03 19:25:21 +0100 <geekosaur> this may include decoding UTF8 or a locale encoding
2021-02-03 19:25:32 +0100pmikkelsen(~pmikkelse@vps1.pmikkelsen.com)
2021-02-03 19:25:46 +0100 <sshine> kuribas, good point (about conciseness.)
2021-02-03 19:25:49 +0100 <geekosaur> (no, strings are not a simple no-thought topic. anywhere, although most programming languages pretend they are)
2021-02-03 19:25:59 +0100lukaswilkeer(b3438885@179-67-136-133.user3p.veloxzone.com.br)
2021-02-03 19:26:47 +0100 <sshine> geekosaur, I think Java did an efficient job at hiding that.
2021-02-03 19:26:47 +0100 <kuribas> and many language conflate binary blobs with strings.
2021-02-03 19:27:17 +0100 <sshine> geekosaur, at least wrt. StringBuilder/StringBuffer
2021-02-03 19:28:25 +0100ixaxaar(~ixaxaar@49.207.210.215) (Ping timeout: 240 seconds)
2021-02-03 19:29:21 +0100son0p(~son0p@181.136.122.143)
2021-02-03 19:30:14 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 19:31:11 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Remote host closed the connection)
2021-02-03 19:31:35 +0100kciN(~zaba@212.58.119.153)
2021-02-03 19:33:09 +0100 <kciN> Hey, guys! I've got `OpenGL` and `GLUT` up to date, but keep getting `user error (unknown GLUT entry glutInit)` when I try to run my app.
2021-02-03 19:33:15 +0100 <shapr> After further digging, looks like Wreq handles cookies transparently by never worrying about expiration.
2021-02-03 19:33:40 +0100 <monochrom> On the flip side, I had Java students who had trouble realizing that they're mistakenly outputting control characters because Java's String.toString() does not escape.
2021-02-03 19:33:57 +0100 <geekosaur> kciN, are you on Windows? you may have to install OpenGL support
2021-02-03 19:34:03 +0100 <monochrom> I had to go to the trouble of suggesting them to use a hexeditor.
2021-02-03 19:34:04 +0100 <kciN> Linux
2021-02-03 19:34:05 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-02-03 19:34:12 +0100 <texasmynsted> Data.ByteString.Lazy.Internal.unpackChars did what I wanted
2021-02-03 19:34:46 +0100 <geekosaur> hm. may still need to install it but it's more likely to be automatically installed on most distros
2021-02-03 19:34:57 +0100 <merijn> texasmynsted: Almost 100% certainly it didn't
2021-02-03 19:35:17 +0100 <merijn> texasmynsted: It merely *appears* to do what you want
2021-02-03 19:35:23 +0100 <texasmynsted> well
2021-02-03 19:35:29 +0100 <monochrom> Hell, I had to use a hexeditor to see why their output mismatched with expected output.
2021-02-03 19:36:06 +0100 <monochrom> This would not have happened with Haskell's show
2021-02-03 19:36:24 +0100 <merijn> monochrom: It's 2021 and I'm still linking to JoelOnSoftware's 2 decade old article about "the bare minimum everyone should know about unicode" :\
2021-02-03 19:36:33 +0100 <kciN> fixed
2021-02-03 19:36:48 +0100 <kciN> (by installing `libfreeglut` on voidlinux)
2021-02-03 19:36:55 +0100 <texasmynsted> what I want is to take the lazy ByteString that is read in from the stdout stream of a process and temporarily write it to the console.
2021-02-03 19:37:05 +0100 <merijn> texasmynsted: That function is a one way trip to "corrupted garbage data town" >.>
2021-02-03 19:37:20 +0100ClaudiusMaximus(~claude@unaffiliated/claudiusmaximus) (Quit: ->)
2021-02-03 19:37:26 +0100 <texasmynsted> merijn: What _should_ I do?
2021-02-03 19:37:29 +0100 <merijn> texasmynsted: You can do that without corrupting it/going through String, though?
2021-02-03 19:37:37 +0100kciN(~zaba@212.58.119.153) ()
2021-02-03 19:37:43 +0100 <merijn> texasmynsted: Well, what do you mean by "console"? stdout/stderr?
2021-02-03 19:38:24 +0100 <texasmynsted> I do not care about String. I care about the stdout stream. It seems to be using \n as newlines in the lazy bytestring
2021-02-03 19:38:42 +0100 <maerwald> use unix package and write to stdout
2021-02-03 19:39:06 +0100 <monochrom> I have trouble believing that you can read stdout.
2021-02-03 19:39:16 +0100 <texasmynsted> stdout for _my_ app, rather than the process that ran where the lazy bytestring was captured
2021-02-03 19:39:20 +0100 <merijn> texasmynsted: https://hackage.haskell.org/package/bytestring-0.11.0.0/docs/Data-ByteString-Lazy.html#v:putStr for example
2021-02-03 19:39:41 +0100 <geekosaur> monochrom, you can if it's a terminal
2021-02-03 19:40:22 +0100 <merijn> monochrom: He said "from a process" reading the stdout of a process is pretty reasonable
2021-02-03 19:40:28 +0100 <texasmynsted> https://hackage.haskell.org/package/typed-process-0.2.6.0/docs/System-Process-Typed.html#t:Process…
2021-02-03 19:40:30 +0100 <geekosaur> the terminal (either a terminal emulator or getty) opens one fd on 0 and dup()s it onto 1 and 2
2021-02-03 19:40:42 +0100lukaswilkeer(b3438885@179-67-136-133.user3p.veloxzone.com.br) (Ping timeout: 240 seconds)
2021-02-03 19:40:43 +0100 <merijn> texasmynsted: FYI you can also simply forward stdout of the child to stdout of the parent directly
2021-02-03 19:40:46 +0100mmohammadi9812(~mmohammad@198.12.95.182) (Read error: Connection reset by peer)
2021-02-03 19:40:54 +0100 <maerwald> yay, unix pipes
2021-02-03 19:40:57 +0100mmohammadi9812(~mmohammad@2.178.213.79)
2021-02-03 19:41:08 +0100urdh(~urdh@unaffiliated/urdh) (Quit: Boom!)
2021-02-03 19:41:20 +0100 <geekosaur> that one doesn;t even need pipes, just default fd inheritance
2021-02-03 19:41:22 +0100 <maerwald> merijn is gonna get high blood pressure
2021-02-03 19:41:26 +0100 <texasmynsted> merijn: That sounds better
2021-02-03 19:41:47 +0100 <merijn> texasmynsted: Incidentally I (personally) find typed-process rather complex
2021-02-03 19:41:52 +0100 <merijn> Needlessly so, that is
2021-02-03 19:42:02 +0100neiluj(~jco@91-167-203-101.subs.proxad.net)
2021-02-03 19:42:02 +0100neiluj(~jco@91-167-203-101.subs.proxad.net) (Changing host)
2021-02-03 19:42:02 +0100neiluj(~jco@unaffiliated/neiluj)
2021-02-03 19:42:29 +0100 <merijn> texasmynsted: In fact, looks like that's the default
2021-02-03 19:42:46 +0100 <merijn> texasmynsted: https://hackage.haskell.org/package/typed-process-0.2.6.0/docs/System-Process-Typed.html#v:inherit that's the default for stdout according to the docs
2021-02-03 19:43:25 +0100catt(~r@31.124.181.226)
2021-02-03 19:45:10 +0100frozenErebus(~frozenEre@37.231.239.43)
2021-02-03 19:45:17 +0100 <texasmynsted> okay. Let me see.
2021-02-03 19:48:47 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-03 19:49:15 +0100juuandyy(~juuandyy@90.106.228.121)
2021-02-03 19:50:48 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-03 19:51:09 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 19:51:44 +0100jiribenes(~jiribenes@rosa.jiribenes.com) (Read error: Connection reset by peer)
2021-02-03 19:52:21 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl)
2021-02-03 19:52:30 +0100jiribenes(~jiribenes@rosa.jiribenes.com)
2021-02-03 19:52:31 +0100jonatanb(~jonatanb@83.24.13.14.ipv4.supernova.orange.pl) (Remote host closed the connection)
2021-02-03 19:53:30 +0100alx741(~alx741@181.196.69.29) (Ping timeout: 258 seconds)
2021-02-03 19:55:09 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-03 19:55:45 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 240 seconds)
2021-02-03 19:56:36 +0100ph88_(~ph88@ip5f5af71a.dynamic.kabel-deutschland.de) (Ping timeout: 240 seconds)
2021-02-03 19:57:29 +0100raehik1(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Client Quit)
2021-02-03 19:59:04 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-03 20:00:38 +0100Tops2(~Tobias@dyndsl-095-033-093-253.ewe-ip-backbone.de) (Read error: Connection reset by peer)
2021-02-03 20:01:23 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Remote host closed the connection)
2021-02-03 20:01:49 +0100asheshambasta(~user@ptr-e1lysavd5pllo57cw5p.18120a2.ip6.access.telenet.be) (Ping timeout: 272 seconds)
2021-02-03 20:02:40 +0100jb55(~jb55@gateway/tor-sasl/jb55) (Remote host closed the connection)
2021-02-03 20:02:50 +0100jpds(~jpds@gateway/tor-sasl/jpds) (Remote host closed the connection)
2021-02-03 20:03:02 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 20:03:05 +0100jb55(~jb55@gateway/tor-sasl/jb55)
2021-02-03 20:03:20 +0100jpds(~jpds@gateway/tor-sasl/jpds)
2021-02-03 20:03:22 +0100berberman_(~berberman@unaffiliated/berberman)
2021-02-03 20:03:51 +0100berberman(~berberman@unaffiliated/berberman) (Ping timeout: 258 seconds)
2021-02-03 20:04:42 +0100shush(~pawn@2603-8000-3703-51f4-217f-fa24-0553-46d3.res6.spectrum.com)
2021-02-03 20:05:03 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-02-03 20:05:45 +0100 <shush> I'm wanting to give haskell a go, but I'm not sure what to build. Any good programs/prompts to follow to really get down the type system and the cool FP things like monads and some other category theory things?
2021-02-03 20:06:56 +0100alx741(~alx741@186.178.110.33)
2021-02-03 20:07:16 +0100jluttine(~jluttine@85-23-95-149.bb.dnainternet.fi)
2021-02-03 20:07:53 +0100 <Logio> shush: if you haven't done a simple "ask a number, print the number"-program yet, start with that. There's enough monads and type theory there to get started
2021-02-03 20:10:51 +0100 <[exa]> shush: also depends on how much functional programming you already tried&survived, for the beginning I'd recommend some simple text processing, or perhaps small games
2021-02-03 20:11:04 +0100 <glguy> shush: if you just want a bunch of things to implement you could do some of the Advent of Code tasks. Many other people have done them so after you implement one, or if you get stuck, you can look up what others did and compare
2021-02-03 20:11:33 +0100 <shush> I'm a JS and TS script kiddie
2021-02-03 20:11:41 +0100d3od(~nickmeno3@78-0-108-194.adsl.net.t-com.hr)
2021-02-03 20:11:56 +0100 <shush> So, I've dealt with the more bastardized versions of FP concepts I guess you could say
2021-02-03 20:11:57 +0100 <[exa]> shush: re games, there's Graphics.Gloss which is just unbelievably good for starting up -- you get a 2D canvas and just supply a function that generates description of what to draw, and you have it drawn. Great for experiments
2021-02-03 20:12:11 +0100 <swarmcollective> I agree with glguy, Advent of Code in Haskell is good fun.
2021-02-03 20:12:39 +0100 <shush> What is the community's preferred package manager for haskell?
2021-02-03 20:12:45 +0100 <[exa]> shush: cabal
2021-02-03 20:13:08 +0100 <aveltras> shush: you could also try https://github.com/kowainik/learn4haskell, haven't used it personally but i think it had good reviews
2021-02-03 20:13:23 +0100 <[exa]> there's also stack but that's a multipurposed compatibility&reproducibility layer above cabal, for starting up it just adds complexity
2021-02-03 20:13:51 +0100 <ski> shush : you're also welcome to ask beginner questions in here
2021-02-03 20:14:16 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 256 seconds)
2021-02-03 20:14:46 +0100 <shush> What are some notable, cool things built in haskell?
2021-02-03 20:15:04 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-03 20:15:07 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex) (Remote host closed the connection)
2021-02-03 20:15:09 +0100 <merijn> shush: pandoc and https://www.shellcheck.net/
2021-02-03 20:15:17 +0100kuribas(~user@ptr-25vy0i8e6su9fkcjvkw.18120a2.ip6.access.telenet.be) (Quit: ERC (IRC client for Emacs 26.3))
2021-02-03 20:15:28 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 20:15:32 +0100 <glguy> shush: I'm chatting with you from something built in Haskell
2021-02-03 20:15:37 +0100ChaiTRex(~ChaiTRex@gateway/tor-sasl/chaitrex)
2021-02-03 20:15:41 +0100 <ski> shush : btw, note that one doesn't really have to learn much CT, if any, to learn how to use the applications in Haskell. but if you happen to be mathematically interested, there are some cool things (which may or may not be that useful practically, atm at least)
2021-02-03 20:15:41 +0100 <merijn> As for Haskell and package managers: https://gist.github.com/merijn/8152d561fb8b011f9313c48d876ceb07
2021-02-03 20:15:59 +0100 <swarmcollective> shush lambdabot https://github.com/lambdabot/lambdabot
2021-02-03 20:16:02 +0100 <swarmcollective> :t zip
2021-02-03 20:16:03 +0100 <lambdabot> [a] -> [b] -> [(a, b)]
2021-02-03 20:16:24 +0100 <ski> @version
2021-02-03 20:16:24 +0100 <lambdabot> lambdabot 5.3.0.1
2021-02-03 20:16:24 +0100 <lambdabot> git clone https://github.com/lambdabot/lambdabot
2021-02-03 20:16:29 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de) (Ping timeout: 256 seconds)
2021-02-03 20:16:36 +0100 <merijn> I would go further and say that "learning category theory" and "learning/becoming better at Haskell programming" are pretty much entirely unrelated goals
2021-02-03 20:17:09 +0100 <merijn> And if learning Haskell programming is the real goal, category theory is mostly a waste of time
2021-02-03 20:17:56 +0100 <aveltras> i'd say the more practice you get, the better
2021-02-03 20:18:00 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-03 20:18:02 +0100geekosaur(82650c7c@130.101.12.124) (Ping timeout: 240 seconds)
2021-02-03 20:18:15 +0100o1lo01ol1o(~o1lo01ol1@bl11-140-216.dsl.telepac.pt)
2021-02-03 20:18:29 +0100 <ski> some CT *might* be useful to know, to design certain types of advanced abstractions or efficiency improvements .. but that's for people who already know all the basics, and one can use Haskell well, and be a power user in it, without having to do anything of the sort
2021-02-03 20:18:30 +0100 <aveltras> don't waste to much time on theory early on
2021-02-03 20:19:12 +0100 <swarmcollective> There's a twitch streamer building the game "Dominion" in Haskell.
2021-02-03 20:19:31 +0100 <merijn> ski: By the time CT might help your Haskell, you would know enough Haskell that you're not asking others how to learn more Haskell ;)
2021-02-03 20:19:42 +0100 <ski> some people learn better, by being motivated by concrete practical uses, applications. some people want to get a clearer overview of the theory and possibilities first. you should try to go for what makes you tick
2021-02-03 20:19:52 +0100 <ski> merijn : yes
2021-02-03 20:20:20 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 258 seconds)
2021-02-03 20:20:36 +0100 <[exa]> shush: one fun thing with haskell is taking a program and finding patterns that can be expressed with high-level library functions, thus minimizing the program to a fraction of original code volume. For the "white what I read" program you can follow from sequential getline/putstring, then >>=, then `interact`, and probably further if 2-words program isn't short enough.
2021-02-03 20:20:45 +0100o1lo01ol_(~o1lo01ol1@bl7-89-228.dsl.telepac.pt) (Ping timeout: 240 seconds)
2021-02-03 20:21:04 +0100 <merijn> aveltras: Lots of theory is useful to learn as a beginner, CT just isn't part of that ;)
2021-02-03 20:21:07 +0100urodna_(~urodna@unaffiliated/urodna)
2021-02-03 20:21:12 +0100 <maerwald> [exa]: you mean golfing
2021-02-03 20:21:29 +0100 <aveltras> the problem with haskell and theory is that it is a bottomless well
2021-02-03 20:21:39 +0100 <shush> main = doEverything input
2021-02-03 20:21:44 +0100 <shush> That'd be the ideal program
2021-02-03 20:21:51 +0100 <shush> jk
2021-02-03 20:21:55 +0100 <aveltras> whenever you try to learn something you always learn about something else connected and you can go on endlessly
2021-02-03 20:21:59 +0100 <[exa]> maerwald: not necessarily golfing, it's more about finding the patterns to memoize them
2021-02-03 20:22:39 +0100 <shush> I think really I want to be proficient to be able to write in haskell, but then I'd like to understand the higher level concepts to be able to get creative
2021-02-03 20:23:01 +0100 <[exa]> such as "oh look this is a traversal"
2021-02-03 20:23:28 +0100urodna(~urodna@unaffiliated/urodna) (Ping timeout: 272 seconds)
2021-02-03 20:23:54 +0100 <[exa]> shush: you will learn lot of highlevel patterns just by coding and refactoring sometimes, don't worry
2021-02-03 20:23:55 +0100cole-h(~cole-h@c-73-48-197-220.hsd1.ca.comcast.net)
2021-02-03 20:24:13 +0100 <merijn> shush: Even basic Haskell includes plenty of higher level concepts to keep you busy :p
2021-02-03 20:24:22 +0100 <shush> noice
2021-02-03 20:24:34 +0100 <aveltras> love to discover new things via hlint suggestions
2021-02-03 20:25:00 +0100 <[exa]> yeah, making `hlint` shut up is super educative. :D
2021-02-03 20:25:17 +0100 <glguy> you have to look up the pragma to turn off the suggestion, paste it in each file, etc
2021-02-03 20:25:19 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net) (Ping timeout: 258 seconds)
2021-02-03 20:25:20 +0100 <ski> a lot of learning is often to memorize various small nifty tricks and patterns
2021-02-03 20:26:12 +0100 <[exa]> shush: btw does TS have monads?
2021-02-03 20:26:21 +0100 <shush> Uh
2021-02-03 20:26:25 +0100deviantfero(~deviantfe@190.150.27.58) (Ping timeout: 240 seconds)
2021-02-03 20:26:45 +0100 <ski> shush : often, one will not immediately see the point of, or use of, various abstraction. or may think that it's not that important. but when one's learned the idea, one may (or may not) find that one spots opportunities for it more often than one would've thought
2021-02-03 20:26:59 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net)
2021-02-03 20:27:01 +0100 <shush> You can implement monads in JS, so I'd say yes, but I don't know if there is some formal definition that it misses
2021-02-03 20:27:06 +0100 <ski> (this is related to "blub")
2021-02-03 20:27:53 +0100 <ski> shush : lurking in this channel, sometimes trying to see what other people are talking about, and also trying to help others, can also be a good way to learn and reinforce, and to be exposed to new things
2021-02-03 20:28:00 +0100 <shush> [exa]: like a monad in its type system?
2021-02-03 20:28:31 +0100urdh(~urdh@unaffiliated/urdh)
2021-02-03 20:29:38 +0100 <shush> My understanding of monads are that they implement two operations: 1. the ability to map over the monad given a lambda which if a monad is returned from the lambda, is the new monad. 2. A way to fold, or get the final value
2021-02-03 20:29:49 +0100 <shush> By of course, that may be an incorrect understanding
2021-02-03 20:29:57 +0100 <[exa]> shush: not necessarily formal definition, the point is just getting the intuition for using them... For me the point where it "clicked" was parsing combinators (these are very cool and quite specific to haskell)
2021-02-03 20:30:44 +0100 <ski> shush : oh, and btw, there is a #haskell-beginners channel. but this channel (#haskell) definitely also welcomes beginner questions and issues. the difference is more one of volume. in here, sometimes one's question may get lost in the noise, or the heat of another discussion. in there, sometimes there's not enough people around who have a clue of how to help. but in there, it can be easier to focus, because
2021-02-03 20:30:49 +0100 <shush> Combinator is a monad that combines the thing? Like addition or string concatenation?
2021-02-03 20:30:50 +0100 <ski> of less other conversation, while in here, it can sometimes be easier (take a shorter time) to get someone's attention
2021-02-03 20:31:09 +0100 <monochrom> shush, neither sounds like "return", and both sound like ">>=", so I think you have a misunderstanding.
2021-02-03 20:31:32 +0100 <shush> monochrom: fold is return, and map is >>=
2021-02-03 20:31:42 +0100 <shush> At least that was what I was attempting to describe
2021-02-03 20:31:58 +0100 <monochrom> Of all concrete examples of Monad and return I have seen, none feel like fold.
2021-02-03 20:31:59 +0100 <ski> "combinator" is a word that is sometimes used to describe library operations that provide "building blocks" for an (Embedded) Domain Specific Language, of some sort
2021-02-03 20:32:00 +0100 <shush> Is there a haskell online playground?
2021-02-03 20:32:11 +0100 <[exa]> shush: combinator is a fancy name for a function with nicely closed scope, worry not about the precise definitions now
2021-02-03 20:32:36 +0100jluttine(~jluttine@85-23-95-149.bb.dnainternet.fi) (Ping timeout: 258 seconds)
2021-02-03 20:33:19 +0100 <ski> shush : "the ability to map over the monad" -- monads are not things you pass to functions (nor return from them). `getLine', of type `IO String', is not a monad (it's an action, a monadic action, an `IO'-action). `IO' itself (together with its `Monad IO' instance, implementing `return' and `(>>=)' for it), is the monad
2021-02-03 20:33:45 +0100 <texasmynsted> okay thank you merijn. I was trying to do things the wrong way.
2021-02-03 20:33:58 +0100juuandyy(~juuandyy@90.106.228.121) (Quit: Konversation terminated!)
2021-02-03 20:34:20 +0100 <texasmynsted> It is far better and less complicated to simply use the parent stream
2021-02-03 20:34:22 +0100 <shush> return will give the internal value of the monad?
2021-02-03 20:34:23 +0100 <monochrom> But at the end of the day, all wordings are useless unless you write correct code and you can predict the outcome of someone else's code.
2021-02-03 20:34:23 +0100hexfive(~hexfive@50.35.83.177)
2021-02-03 20:34:26 +0100 <[exa]> shush: the point is that in haskell, monads are used to write imperative-like code; you can view them (in a very limited view!) as overloaded semicolons and assignment. So for example, monads can do sequential IO (the semicolon makes sure that actions are executed in order), or parsing (the semicolons make sure that parsing context gets carried around correctly) or exceptions (the semicolon doesn't execute
2021-02-03 20:34:26 +0100 <shush> I think of monads as boxes
2021-02-03 20:34:32 +0100 <[exa]> the rest of the program if there was an error), etc.
2021-02-03 20:35:38 +0100 <ski> in the case of parsing, you have parsing combinators that help build up larger parsers from smaller ones (as opposed to defining larger parsing *functions*, by calling smaller ones). only "at the end" do you actually run the parser with some input. the building process happens before that
2021-02-03 20:35:38 +0100 <glguy> shush: you'll do better to use monads for a while to develop an understanding than to guess
2021-02-03 20:35:53 +0100 <shush> glguy: Yeah, I'll need to grok at it more
2021-02-03 20:36:21 +0100 <tdammers> honestly, I think the box analogy does more harm than good, at least until you have developed an intuition for the "monad" abstraction
2021-02-03 20:36:26 +0100 <monochrom> Yeah I don't understand spending a month crafting a wording before any example, or even a million examples.
2021-02-03 20:36:35 +0100 <monochrom> I don't see people learning chess like that.
2021-02-03 20:36:40 +0100 <ski> shush : `return' is a function that, given any value, will give you back a monadic *action*, which, when later (if ever) executed, will perform no "effect", and just yield the passed value back as result
2021-02-03 20:37:02 +0100 <shush> But in my JS/TS experience, a Promise is a monad. The justification here is that I can do .then(f) as the next imperative execution on that monad.
2021-02-03 20:37:08 +0100deviantfero(~deviantfe@190.150.27.58)
2021-02-03 20:37:15 +0100 <ski> shush : it expresses a "nop", a "do nothing" operation (apart from specifying what the result value should be)
2021-02-03 20:37:20 +0100 <monochrom> I don't see people discussing "the knight is about ..." or "the knight means ..." before they have even played a hundred games.
2021-02-03 20:37:46 +0100 <monochrom> Imagine stepping into a chess club and seeing everyone talking not playing.
2021-02-03 20:37:49 +0100 <shush> ski: Is return like a way of defining the case for a monad?
2021-02-03 20:37:59 +0100 <shush> or the return for a particular case?
2021-02-03 20:38:28 +0100 <monochrom> And even better, congratulating each other for "nailing how to do an elevator pitch for the rook".
2021-02-03 20:38:54 +0100 <ski> shush : `return' is used when you have branching, and in some branch you want to do nothing at all. it's also used to explicitly set the result value of executing the action, in case the otherwise last action (in your sequence of action) doesn't provide the result value that you wanted
2021-02-03 20:39:05 +0100thongpv87(~thongpv87@103.6.151.121)
2021-02-03 20:39:29 +0100 <tdammers> I think it's best to think of `return` simply as a function for lifting values to monadic actions
2021-02-03 20:39:40 +0100 <ephemient> shush: .then(_ => 1) and .then(_ => Promise.resolve(1)) have the same behavior, which is not really monadic... but JS isn't typed so ¯\_(ツ)_/¯
2021-02-03 20:40:04 +0100 <[exa]> shush: promises carry some very relevant intuition, yes. `then` has the same "parameter types" as >>=. Highly suggest you go try some simple programs (writing a few numbers etc) and try to see the type of everything with :t in ghci.
2021-02-03 20:40:05 +0100 <shush> ephemient: I thought was the reason why it was monadic
2021-02-03 20:40:06 +0100 <shush> haha
2021-02-03 20:40:15 +0100 <tdammers> I also think that trying to form an intuition for monads is *much* harder without the help of a type system like Haskell's
2021-02-03 20:40:18 +0100deviantfero(~deviantfe@190.150.27.58) (Read error: Connection reset by peer)
2021-02-03 20:40:30 +0100 <ephemient> `>>= 1` and `>>= return 1` aren't the same thing
2021-02-03 20:40:43 +0100 <ski> shush : it appears to be the case, that for most people, the way to learn monads is not to learn the abstract idea first, but to learn many concrete monads (`Maybe',`Either e',`[]',`Reader r',`Writer w',`State s',`Cont o',`IO',`Parser',...), and only *then* start to realize what all these *wildly* differing things have in common
2021-02-03 20:40:44 +0100 <shush> Gotta get my hands dirty before I can fully get it then
2021-02-03 20:41:05 +0100 <tdammers> http://dev.stephendiehl.com/hask/#eightfold-path-to-monad-satori <- relevant
2021-02-03 20:41:09 +0100 <shush> ski: Spot the pattern ;)
2021-02-03 20:41:20 +0100 <monochrom> Anyway, you can enter and run some Haskell code at http://codepad.org/
2021-02-03 20:42:23 +0100 <monochrom> IMO more people should learn chess, and learn things more like learning chess.
2021-02-03 20:42:30 +0100 <[exa]> shush: anyway, don't hesitate to pastebin your code and post it here (or in #haskell-beginners) for suggestions, people here love nitpicking others' code. :]
2021-02-03 20:42:33 +0100 <ski> shush : but to give a very brief (and incomplete) overview/analogy. "monad" is an abstract interface, comparable to "priority queue". just like you can have many differing implementations of a priority queue, you can also have many differing implementations of the monad interface
2021-02-03 20:42:48 +0100 <shush> (\ x -> y) is a lambda in haskell?
2021-02-03 20:42:51 +0100 <swarmcollective> let x = Just 1
2021-02-03 20:42:54 +0100 <swarmcollective> :t x
2021-02-03 20:42:55 +0100 <lambdabot> Expr
2021-02-03 20:42:56 +0100kritzefitz(~kritzefit@212.86.56.80) (Remote host closed the connection)
2021-02-03 20:43:34 +0100 <monochrom> You learn chess you learn that you don't start with a white-paper drivel that a management type or marketing type understands.
2021-02-03 20:43:53 +0100 <ski> shush : *however*, while for priority queues, most of the useful functionality is in the interface, and only very little is in the specific implementation (perhaps you set an initial capacity for an array-backed PQ), for *monads* otoh, *most* of the useful functionality is *specific* to the monad in question you're using, and only very little is in the "monad" interface
2021-02-03 20:44:01 +0100 <monochrom> You start with the "dry" "meaningless" rules. Then you play. And fail. Repeat 100 times.
2021-02-03 20:44:14 +0100 <monochrom> Only then, you are ready to discuss meanings and strategies.
2021-02-03 20:44:18 +0100 <ephemient> \ is how Haskell spells λ in ASCII
2021-02-03 20:44:32 +0100 <swarmcollective> >show x
2021-02-03 20:44:45 +0100 <swarmcollective> (lambdabot says "Nope.")
2021-02-03 20:44:47 +0100 <[exa]> shush: it's a function, lambda is the \ sign.
2021-02-03 20:45:09 +0100 <ephemient> hmm it seems that λ isn't recognized even in -XUnicodeSyntax mode though
2021-02-03 20:45:27 +0100 <ephemient> I guess it's difficult since it parses as a letter rather than a symbol
2021-02-03 20:46:11 +0100jluttine(~jluttine@85-23-95-149.bb.dnainternet.fi)
2021-02-03 20:46:24 +0100 <ski> shush : oh right .. most "monad tutorials" don't really help much, often arguably even hinders understanding
2021-02-03 20:47:10 +0100 <ski> swarmcollective : you need to use `@let'
2021-02-03 20:47:27 +0100 <ski> (also, it will be ambiguous with an existing binding for `x')
2021-02-03 20:47:33 +0100 <ski> @type let x = Just 1 in x
2021-02-03 20:47:34 +0100 <lambdabot> Num a => Maybe a
2021-02-03 20:47:38 +0100worc3131(~quassel@2a02:c7f:dcc4:6500:217b:6c7a:eac3:3be9)
2021-02-03 20:48:01 +0100 <swarmcollective> ski, thank you!
2021-02-03 20:48:21 +0100 <ski> monochrom : i wonder whether the management type or marketing type really understands it ..
2021-02-03 20:48:22 +0100 <monochrom> But monad is much much broader than priority queue.
2021-02-03 20:48:42 +0100 <ski> ephemient : yes
2021-02-03 20:48:42 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 20:48:43 +0100 <monochrom> monad and container are more or less equally broad.
2021-02-03 20:49:00 +0100 <ski> yep
2021-02-03 20:49:00 +0100 <monochrom> Fortunately, monad has a rigorous definition, container doesn't.
2021-02-03 20:49:24 +0100ski. o O ( representable functor )
2021-02-03 20:50:51 +0100deviantfero(~deviantfe@190.150.27.58)
2021-02-03 20:51:01 +0100 <monochrom> I'm sure if your white paper says "one thing monads can do very well is expressing proprietory business logic" they will understand perfectly.
2021-02-03 20:51:12 +0100 <maerwald> lol
2021-02-03 20:51:30 +0100 <dolio> That might even be true.
2021-02-03 20:51:43 +0100 <monochrom> Inspired by just last night average's drivel included "I found this in huffington post, haskell is ideally suited for proprietory business logic..."
2021-02-03 20:51:45 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 20:51:46 +0100knupfer(~Thunderbi@200116b82c27b900392e02b43800d436.dip.versatel-1u1.de) (Ping timeout: 258 seconds)
2021-02-03 20:52:09 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 20:52:14 +0100 <monochrom> So yeah basically I have nailed writing the perfect white paper. Just bring up "proprietory business logic".
2021-02-03 20:52:24 +0100 <maerwald> monads are like relationships: you join, but you can't get out of it
2021-02-03 20:52:51 +0100 <monochrom> That sounds like fairly specifically relationships with spies and/or gangs, but yeah.
2021-02-03 20:53:05 +0100 <maerwald> Yeah, grew up in the hood...
2021-02-03 20:53:11 +0100 <swarmcollective> maerwald The "Hotel California" of programming.
2021-02-03 20:53:17 +0100 <ski> swarmcollective : note that numeric literals are overloaded. hence the `Num a =>'
2021-02-03 20:53:54 +0100 <ski> well, i'm not so sure what "expressing proprietory business logic" even means, more specifically
2021-02-03 20:54:09 +0100 <swarmcollective> ski, thanks for that. I had skimmed over the `Num a =>` constraint.
2021-02-03 20:54:24 +0100 <ski> swarmcollective : do you know how to read the type it gave ?
2021-02-03 20:54:32 +0100 <swarmcollective> Yes.
2021-02-03 20:55:09 +0100 <swarmcollective> ski, err, I *think* so. ;)
2021-02-03 20:55:37 +0100 <monochrom> ski, that's the point I would think.
2021-02-03 20:56:09 +0100mouseghost(~draco@wikipedia/desperek)
2021-02-03 20:56:15 +0100 <ski> well, `x :: Num a => Maybe a' means that for any type `a' (that the user/consumer/caller picks), `x' will have type `Maybe a', as long as `a' is an instance of the type class `Num' (iow, "is a numeric type")
2021-02-03 20:56:38 +0100 <monochrom> The human mind wants to look for comfort words, and wants to avoid asking difficult semantic questions.
2021-02-03 20:56:59 +0100 <ski> monochrom : well, the question is whether there's actually something for them to understand, in there, or if it's just a kind of bonding phrase or something
2021-02-03 20:57:23 +0100 <monochrom> I think "bonding phrase" nails it.
2021-02-03 20:57:33 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 264 seconds)
2021-02-03 20:57:40 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 272 seconds)
2021-02-03 20:57:45 +0100lawid(~quassel@dslb-090-186-199-238.090.186.pools.vodafone-ip.de) (Ping timeout: 240 seconds)
2021-02-03 20:57:58 +0100geekosaur(82650c7c@130.101.12.124)
2021-02-03 20:58:10 +0100 <ski> (and not to derail bonding phrases and the like .. such things are important, in a community. but one'd hope there'd be more to most of the interactions, than such things)
2021-02-03 20:58:22 +0100ixian(~mgold@2002:4a74:ba78:1701:0:ff:fe78:6269) (Ping timeout: 265 seconds)
2021-02-03 20:58:33 +0100livvy(~livvy@gateway/tor-sasl/livvy) (Remote host closed the connection)
2021-02-03 20:58:43 +0100mmohammadi9812(~mmohammad@2.178.213.79) (Remote host closed the connection)
2021-02-03 20:58:49 +0100livvy(~livvy@gateway/tor-sasl/livvy)
2021-02-03 20:58:52 +0100lawid(~quassel@dslb-088-073-132-251.088.073.pools.vodafone-ip.de)
2021-02-03 20:59:01 +0100mmohammadi9812(~mmohammad@2.178.213.79)
2021-02-03 20:59:25 +0100skialways found it confusing when people say "you're arguing semantics", as if that would be a rebuttal
2021-02-03 20:59:30 +0100stef204(~stef204@unaffiliated/stef-204/x-384198) (Quit: WeeChat 3.0)
2021-02-03 20:59:37 +0100 <Rembane> What would you otherwise argue? Syntax?
2021-02-03 20:59:56 +0100 <ski> presumably. or perhaps pragmatics .. or maybe something else, i dunno
2021-02-03 21:00:10 +0100 <ski> but semantics seems to be quite important, in many areas
2021-02-03 21:00:16 +0100 <maerwald> logic?
2021-02-03 21:00:30 +0100 <ski> (i suppose e.g. aesthetics is another one that's important)
2021-02-03 21:01:23 +0100ixian(~mgold@2002:4a74:ba78:1701:0:ff:fe78:6269)
2021-02-03 21:01:26 +0100 <ski> (e.g. "every structure ought to come with a notion of structure-preserving morphism" is an *aesthetic* dogma)
2021-02-03 21:02:01 +0100 <maerwald> is it? It allows to make assumptions
2021-02-03 21:02:17 +0100 <ski> is what what ?
2021-02-03 21:02:38 +0100geyaeb(~geyaeb@gateway/tor-sasl/geyaeb) (Quit: ZNC 1.8.2 - https://znc.in)
2021-02-03 21:02:54 +0100 <maerwald> an asthetic dogma
2021-02-03 21:02:58 +0100ph88_(~ph88@2a02:8109:9e00:7e5c:ade8:bbad:5afb:2c7)
2021-02-03 21:03:00 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Remote host closed the connection)
2021-02-03 21:03:00 +0100geyaeb(~geyaeb@gateway/tor-sasl/geyaeb)
2021-02-03 21:03:32 +0100 <monochrom> That one I tend to go the opposite direction. I don't understand what "structure" refers to. Ah but if you tell me what your morphisms preserve, then "ah so that's your structure".
2021-02-03 21:04:37 +0100finn_elija(~finn_elij@gateway/tor-sasl/finnelija/x-67402716) (Remote host closed the connection)
2021-02-03 21:05:10 +0100finn_elija(~finn_elij@gateway/tor-sasl/finnelija/x-67402716)
2021-02-03 21:06:30 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-03 21:07:03 +0100worc3131(~quassel@2a02:c7f:dcc4:6500:217b:6c7a:eac3:3be9) (Ping timeout: 272 seconds)
2021-02-03 21:07:50 +0100cods(~fred@82-65-232-44.subs.proxad.net) (Ping timeout: 264 seconds)
2021-02-03 21:08:13 +0100mputz(~Thunderbi@dslb-088-064-063-125.088.064.pools.vodafone-ip.de)
2021-02-03 21:08:14 +0100cods(~fred@82-65-232-44.subs.proxad.net)
2021-02-03 21:09:02 +0100ph88_(~ph88@2a02:8109:9e00:7e5c:ade8:bbad:5afb:2c7) (Ping timeout: 260 seconds)
2021-02-03 21:09:21 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net)
2021-02-03 21:09:22 +0100 <ski> maerwald : i'm not sure how you're connecting "allows to make assumptions" with it (what do you even mean by that phrase ?)
2021-02-03 21:10:16 +0100 <ski> monochrom : i commonly use that route for "container","effect","execute"
2021-02-03 21:10:19 +0100 <maerwald> "every X has to come with Y" allows to make assumptions in a system, where you have X
2021-02-03 21:10:45 +0100 <ski> iow, if it's a monad, then, by definition, it expresses a notion of effect, comes with a notion of execution
2021-02-03 21:11:13 +0100 <ski> if it's a (covariant) functor, it corresponds to a notion of "container"
2021-02-03 21:11:47 +0100 <ski> (perhaps one should make some assumptions about relevant categories being "concrete" .. but i'm not sure whether that's always warranted)
2021-02-03 21:12:23 +0100 <ski> maerwald : in this case, it's an "ought", not necessarily a "will"
2021-02-03 21:13:19 +0100 <maerwald> ok, I hate english too
2021-02-03 21:13:29 +0100 <ski> :)
2021-02-03 21:15:19 +0100 <dolio> Are morphisms the right thing, though?
2021-02-03 21:15:43 +0100 <ski> any other candidates or generalizations in mind ?
2021-02-03 21:15:50 +0100 <dolio> Relations.
2021-02-03 21:15:52 +0100 <maerwald> transformers, lol
2021-02-03 21:16:11 +0100 <monochrom> Allegories have relations as morphisms. >:)
2021-02-03 21:16:18 +0100frozenErebus(~frozenEre@37.231.239.43) (Ping timeout: 258 seconds)
2021-02-03 21:16:24 +0100 <ski> yea, was just about to mention allegories
2021-02-03 21:16:32 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-03 21:16:34 +0100 <dolio> Category theorists use morphisms to determine structure, as monochrom said. However, that ends up classifying some things unnaturally in some ways.
2021-02-03 21:17:45 +0100 <ski> "Algebra of Programming" uses relations as specifications of problems, and then particular implementations are functional relations that're derived from them
2021-02-03 21:18:02 +0100 <dolio> For instance, the inverse operation on a group is classified as a property, not structure, on a monoid by category theorists.
2021-02-03 21:18:35 +0100 <dolio> But if you use structure preserving relations, it is structure.
2021-02-03 21:18:38 +0100 <ski> i've seen both
2021-02-03 21:19:21 +0100 <ski> can you elaborate on the "But" part ?
2021-02-03 21:19:57 +0100average(uid473595@gateway/web/irccloud.com/x-rcklrhokomuilocj) (Quit: Connection closed for inactivity)
2021-02-03 21:22:27 +0100 <dolio> Monoid morphisms always are always group morphisms provided the monoids happen to be groups. So that gets classified as a property by the sysematic category theory study of this sort of thing. However, monoid congruences need not respect inverses for monoids that happen to be groups.
2021-02-03 21:24:40 +0100 <dolio> You can go in the other direction, too, to homotopy type theory, and consider equivalences. Then being a monoid is a property of a semigroup, because equivalences of semigroups necessarily respect units. However, morphisms of semigroups need not take units to units for semigroups that are monoids, so it gets classified as structure that way.
2021-02-03 21:25:10 +0100hiroaki(~hiroaki@ip4d167562.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2021-02-03 21:25:26 +0100Sheilong(uid293653@gateway/web/irccloud.com/x-duetsgbgiyfgeatn)
2021-02-03 21:26:27 +0100hiroaki(~hiroaki@ip4d167562.dynamic.kabel-deutschland.de)
2021-02-03 21:26:37 +0100 <ski> a monoid congruence ⌜R : M → Ω ← N⌝ is a binary relation between two monoids ⌜M⌝ and ⌜N⌝ such that ⌜1 R 1⌝ and, if ⌜m₀ R n₀⌝ and ⌜m₁ R n₁⌝, then ⌜m₀⋅m₁ R n₀⋅n₁⌝ ?
2021-02-03 21:27:01 +0100 <dolio> Yes.
2021-02-03 21:28:23 +0100 <ski> "consider equivalences" as the morphisms in question ?
2021-02-03 21:28:54 +0100son0p(~son0p@181.136.122.143) (Quit: Lost terminal)
2021-02-03 21:29:22 +0100sh9(~sh9@softbank060116136158.bbtec.net)
2021-02-03 21:30:05 +0100Guest88(~textual@2607:fea8:1300:266:dd64:bfef:2d87:cdc4)
2021-02-03 21:30:43 +0100Guest88(~textual@2607:fea8:1300:266:dd64:bfef:2d87:cdc4) (Client Quit)
2021-02-03 21:32:16 +0100 <dolio> You can probably look at it that way. But equivalences are the analogues of morphisms for groupoids, and you might want to consider groupoids to be more fundamental than categories.
2021-02-03 21:33:28 +0100 <dolio> Because, like, type theory naturally gives rise to that sort of notion for every type.
2021-02-03 21:34:45 +0100shiraeeshi(~shiraeesh@109.166.56.5) (Ping timeout: 240 seconds)
2021-02-03 21:36:19 +0100 <hseg> ok, so type formation/elimination rules give rise to a notion of congruence, which are weaker than what we'd call morphism laws?
2021-02-03 21:37:08 +0100 <hseg> which means that the property/structure classification becomes more systematic?
2021-02-03 21:38:02 +0100dhouthoo(~dhouthoo@ptr-eitgbj2w0uu6delkbrh.18120a2.ip6.access.telenet.be) (Quit: WeeChat 3.0)
2021-02-03 21:41:01 +0100 <swarmcollective> Do discussions about Monads always become discussions around Category Theory? :) (Where's the "my head is spinning emoji?)
2021-02-03 21:41:31 +0100 <monochrom> Yes.
2021-02-03 21:41:36 +0100 <geekosaur> only in #haskell
2021-02-03 21:41:53 +0100 <hseg> dolio: would appreciate pointers in this regard
2021-02-03 21:42:08 +0100rmk236(~lcampos@2a02:908:3616:b100:9d94:72c:d22d:2612)
2021-02-03 21:42:12 +0100 <monochrom> This is a good thing. The theory of reinforcement learning says that this teaches you to not discuss monads in the first place.
2021-02-03 21:42:27 +0100jess(jess@freenode/staff/jess) (Quit: Leaving)
2021-02-03 21:42:27 +0100 <swarmcollective> geekosaur, I thought that was #haskell-in-depth
2021-02-03 21:42:47 +0100 <monochrom> There is really nothing to discuss. Use monads. Get things done. Don't talk.
2021-02-03 21:43:02 +0100 <geekosaur> #haskell-in-depth was one of several failed attempts to get the whole mess out of #haskell
2021-02-03 21:44:31 +0100 <swarmcollective> In my personal experience, "doing" is helping more than "asking / discussing", but it was hard to find a project to dig into.
2021-02-03 21:44:56 +0100 <swarmcollective> At the same time, I appreciate those who have been patient enough to explain to me.
2021-02-03 21:45:06 +0100jess|(jess@freenode/staff/jess)
2021-02-03 21:45:12 +0100 <monochrom> No. Exercises. Typoclasspedia and data61 have exercises.
2021-02-03 21:45:35 +0100 <dolio> hseg: All the classifications are systematic. But relations/congruence classifies the most stuff as "structure" instead of "properties" and equivalences classify the most stuff as "properties". Morphisms is intermediate between the two.
2021-02-03 21:45:55 +0100 <monochrom> And at the scale of data61 (spamming you with exercises), it begins to feel like a neverending project anyway.
2021-02-03 21:46:06 +0100 <monochrom> or a death march project, who knows.
2021-02-03 21:47:06 +0100jess|jess
2021-02-03 21:47:29 +0100 <dolio> Probably no one can tell you any good reason for one being chosen as the 'right' choice.
2021-02-03 21:48:17 +0100 <dolio> The congruence stuff is discussed in this paper: https://www.cs.bham.ac.uk/~udr/papers/logical-relations-and-parametricity.pdf
2021-02-03 21:49:49 +0100kupi(uid212005@gateway/web/irccloud.com/x-qetuytxtunbuqszx) (Quit: Connection closed for inactivity)
2021-02-03 21:50:24 +0100 <dolio> And there is some sense in which congruences characterize something about the algebraic structures that morphism fail to characterize.
2021-02-03 21:54:18 +0100 <hseg> ok, thanks
2021-02-03 21:54:19 +0100fendor(~fendor@91.141.2.117.wireless.dyn.drei.com) (Remote host closed the connection)
2021-02-03 21:54:43 +0100 <dolio> "Isomorphism" in that paper is what I've been calling equivalence.
2021-02-03 21:55:26 +0100 <ski> dolio : ".. naturally gives rise to that sort of notion for every type" -- are you thinking of things like ⌜∀ X. X → X⌝ ?
2021-02-03 21:56:23 +0100 <ski> swarmcollective : we like talking about both more beginner and more advanced stuff, and both more practical-oriented and theoretical stuff
2021-02-03 21:56:45 +0100honigkuchen(~honigkuch@ip5b429953.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2021-02-03 21:56:55 +0100 <ski> (different people may have differing inclinations, obviously. i was talking about the general picture)
2021-02-03 21:57:25 +0100 <dolio> I mean that the identity type in Martin-löf type theory is the type of equivalences. Every type has an identity type, and MLTT is pretty easy to get a handle on. The type theories where every type is a category are super complicated.
2021-02-03 21:58:11 +0100 <ski> monochrom : "Shut up and code !" ? :P
2021-02-03 21:58:34 +0100 <monochrom> Sometimes, shut up and calculate.
2021-02-03 21:58:46 +0100ski. o O ( "Calculemus !" )
2021-02-03 21:58:49 +0100 <monochrom> My definition of "understand" is "have predictive power".
2021-02-03 21:58:59 +0100 <dolio> And lots of types will just have 'categorical' structure that is just forgetting that the groupoid structure is symmetric.
2021-02-03 21:59:51 +0100 <monochrom> "monad is about computation" doesn't help you predict much. However, a simple law like ">>= is associative" can get you very far.
2021-02-03 22:00:00 +0100p-core(~Thunderbi@2001:718:1e03:5128:3697:eeda:19aa:8e56) (Ping timeout: 258 seconds)
2021-02-03 22:00:11 +0100 <ski> dolio : ooh, Uday Reddy
2021-02-03 22:00:12 +0100_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-02-03 22:00:18 +0100 <ski> ty
2021-02-03 22:01:19 +0100swarmcollective(~joseph@cpe-65-31-18-174.insight.res.rr.com) (Ping timeout: 256 seconds)
2021-02-03 22:01:24 +0100 <ski> monochrom : not about "cavalier power", as well ?
2021-02-03 22:03:17 +0100 <monochrom> Oh, there is no cavalier power on either side in the context of comparing a blog post with a monad law in terms of how much they help understanding.
2021-02-03 22:03:55 +0100 <monochrom> Instead, in this context, predictive power is opposed to feeling good about yourself.
2021-02-03 22:03:58 +0100p-core(~Thunderbi@2001:718:1e03:5128:3697:eeda:19aa:8e56)
2021-02-03 22:04:33 +0100nfip^(nfip@ip98-184-89-2.mc.at.cox.net) ()
2021-02-03 22:04:37 +0100usr25(~J@145.red-83-58-207.dynamicip.rima-tde.net)
2021-02-03 22:04:47 +0100 <monochrom> Right? When a management type sees "this thing helps with business logic" they understand nothing, they have actually learned nothing, they just feel better.
2021-02-03 22:06:08 +0100fendor(~fendor@91.141.2.117.wireless.dyn.drei.com)
2021-02-03 22:07:31 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-03 22:08:24 +0100hiroaki(~hiroaki@ip4d167562.dynamic.kabel-deutschland.de) (Remote host closed the connection)
2021-02-03 22:08:33 +0100Younder(~john@33.51-174-155.customer.lyse.net)
2021-02-03 22:08:49 +0100p-core(~Thunderbi@2001:718:1e03:5128:3697:eeda:19aa:8e56) (Ping timeout: 258 seconds)
2021-02-03 22:10:10 +0100ADG1089__(~aditya@223.236.190.35)
2021-02-03 22:13:53 +0100hiroaki(~hiroaki@ip4d167562.dynamic.kabel-deutschland.de)
2021-02-03 22:14:44 +0100conal(~conal@64.71.133.70)
2021-02-03 22:18:15 +0100 <koz_> Is there something equivalent to 'SomeProxy'?
2021-02-03 22:19:45 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 246 seconds)
2021-02-03 22:21:02 +0100knupfer(~Thunderbi@200116b82c27b9002d81d776aa1cc87b.dip.versatel-1u1.de)
2021-02-03 22:23:45 +0100fendor_(~fendor@77.119.129.25.wireless.dyn.drei.com)
2021-02-03 22:24:45 +0100p-core(~Thunderbi@2001:718:1e03:5128:3697:eeda:19aa:8e56)
2021-02-03 22:26:32 +0100 <ij> what document should I consult to learn about what is WHNF?
2021-02-03 22:26:57 +0100fendor(~fendor@91.141.2.117.wireless.dyn.drei.com) (Ping timeout: 264 seconds)
2021-02-03 22:27:17 +0100dxld(~dxld@rush.pub.dxld.at) (Quit: Bye)
2021-02-03 22:28:16 +0100 <[exa]> ij: it shold have a "rigorous" definition somewhere... https://wiki.haskell.org/Weak_head_normal_form
2021-02-03 22:28:17 +0100ADG1089__(~aditya@223.236.190.35) (Remote host closed the connection)
2021-02-03 22:29:18 +0100 <wz1000> koz_: Some Proxy? https://hackage.haskell.org/package/some-1.0.2/docs/Data-Some.html
2021-02-03 22:29:21 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-02-03 22:29:49 +0100tsrt^(tsrt@ip98-184-89-2.mc.at.cox.net)
2021-02-03 22:29:52 +0100 <koz_> wz1000: Yes, that will do very nicely.
2021-02-03 22:30:27 +0100 <ij> what are examples of values that aren't in WHNF?
2021-02-03 22:30:40 +0100xff0x_(~xff0x@2001:1a81:536f:2100:2f3c:8f56:462:e9ab) (Ping timeout: 258 seconds)
2021-02-03 22:30:55 +0100 <[exa]> ij: if you heard "redex" definition (an applied lambda, basically), expression in HNF is one with no redex in the topmost grammar production
2021-02-03 22:31:08 +0100 <geekosaur> that's not how WHNF works
2021-02-03 22:31:26 +0100deviantfero(~deviantfe@190.150.27.58) (Ping timeout: 258 seconds)
2021-02-03 22:31:37 +0100 <geekosaur> WHNF is a state in the lazy evluation of some value, not an attribute which some values have
2021-02-03 22:32:32 +0100xff0x_(xff0x@gateway/vpn/mullvad/xff0x)
2021-02-03 22:32:45 +0100 <[exa]> geekosaur: hm, does the definition on haskell wiki make sense then?
2021-02-03 22:32:57 +0100 <geekosaur> for example, if you have the list ['a'], successive evaluations to WHNF get you: (_:_), ('a':_), ('a':[]). the _ represents something which is not yet in WHNF and is therefore not yet known
2021-02-03 22:33:36 +0100 <ij> geekosaur, what I meant by that "value" is the state in the evaluation
2021-02-03 22:34:21 +0100soft-warm(4408f588@ip68-8-245-136.sd.sd.cox.net) (Quit: Connection closed)
2021-02-03 22:35:11 +0100 <ij> ah, function applications aren't in whnf
2021-02-03 22:36:12 +0100 <ij> what is wrong with calling it a value? should it be term?
2021-02-03 22:37:03 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2021-02-03 22:37:19 +0100 <geekosaur> in my example they're all the same value. what differs is how far evaluation has proceeded
2021-02-03 22:37:22 +0100soft-warm(4408f588@ip68-8-245-136.sd.sd.cox.net)
2021-02-03 22:37:46 +0100 <geekosaur> also arguably there's an initial state _ when nothing has been evaluated to WHNF yet
2021-02-03 22:37:48 +0100 <ij> term then?
2021-02-03 22:38:03 +0100 <ij> I read a book about progarmming languages, I know there must be a word for it
2021-02-03 22:38:37 +0100 <[exa]> geekosaur: my understanding is that `undefined:undefined` is a WHNF, does that sound right?
2021-02-03 22:39:01 +0100 <ij> I think so, because it's a data constructor (:) undefined undefined
2021-02-03 22:39:10 +0100 <[exa]> ij: there's the "normal forms" in lambda calculus, and there's their use in haskell, which is slightly different
2021-02-03 22:40:16 +0100xff0x_(xff0x@gateway/vpn/mullvad/xff0x) (Ping timeout: 272 seconds)
2021-02-03 22:40:26 +0100 <[exa]> in lambda calculus, the head normal form means that the topmost term structure is not in form of `(λx.A)B` (that's a redex)
2021-02-03 22:40:47 +0100 <[exa]> "normal form" means there's no redexes at all in whole expression, getting normal forms is undecidable btw.
2021-02-03 22:41:04 +0100 <ij> why not call it just application? :) but sure, if you say redex = application, no problem
2021-02-03 22:41:16 +0100 <ij> http://lampwww.epfl.ch/teaching/archive/type_systems/2008/exercises/3-typed/ it's called an application here
2021-02-03 22:41:23 +0100 <ij> but that is not too important
2021-02-03 22:41:28 +0100 <geekosaur> [exa], the constructor (:) is in WHNF, the rest of the expression is not. I suppose in that sense we can speak of values
2021-02-03 22:41:41 +0100 <[exa]> in haskell, the weak head normal form is useful because it describes the fact that something can be patternmatched "a bit"
2021-02-03 22:41:45 +0100xff0x_(~xff0x@2001:1a81:536f:2100:2f3c:8f56:462:e9ab)
2021-02-03 22:42:25 +0100 <dolio> Head normal form is a weird one that rarely corresponds to any actual evaluation strategy.
2021-02-03 22:42:44 +0100sh9(~sh9@softbank060116136158.bbtec.net) (Quit: WeeChat 2.8)
2021-02-03 22:42:50 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 22:42:58 +0100 <merijn> [exa]: Not true that it's undecidable :p
2021-02-03 22:42:59 +0100 <[exa]> ij: if you have `((\x.x) (\x.x)) A`, it's an application but not a redex.
2021-02-03 22:43:06 +0100 <merijn> [exa]: It depends on the exact lambda calculus
2021-02-03 22:43:20 +0100 <ij> [exa], ah
2021-02-03 22:43:22 +0100 <[exa]> merijn: ah okay
2021-02-03 22:43:34 +0100 <ij> https://wiki.haskell.org/Performance/Strictness
2021-02-03 22:43:38 +0100 <merijn> [exa]: In the simply typed lambda calculus the algorithm for determining the existence is easy, for example
2021-02-03 22:43:43 +0100 <ij> why is "lgo" strict in "z"?
2021-02-03 22:43:50 +0100 <merijn> [exa]: Since the algorithm is "const True" ;)
2021-02-03 22:43:51 +0100 <[exa]> I know, worry not. I didn't want to jump to types
2021-02-03 22:44:01 +0100 <ij> with -O flag, that is
2021-02-03 22:44:02 +0100swarmcollective(~joseph@cpe-65-31-18-174.insight.res.rr.com)
2021-02-03 22:44:11 +0100 <[exa]> ij: because it's fasterer
2021-02-03 22:44:39 +0100 <ij> so being or not being strict is not set in stone/arbitrary
2021-02-03 22:45:12 +0100 <[exa]> if something is strict, the compiler can on one side assume that the data is always there (not an exception/undefined/thunk/whatever), and on the other side it needs to produce the WHNF so that the thing is actually there
2021-02-03 22:45:19 +0100cr3(~cr3@192-222-143-195.qc.cable.ebox.net) (Quit: leaving)
2021-02-03 22:45:37 +0100 <ij> alright, makes sense
2021-02-03 22:46:07 +0100 <[exa]> making stuff strict is a vital means of optimization (each strictness annotation removes one "if" from the code), but if done wrong, it can make your program fail even if it normally wouldn't
2021-02-03 22:46:19 +0100 <ij> really
2021-02-03 22:46:49 +0100 <ij> how could it make it fail? wouldn't having a well-typed program prohibit that?
2021-02-03 22:46:51 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2021-02-03 22:47:07 +0100 <[exa]> ij: consider `f = 1+f; g = const 1 f`
2021-02-03 22:47:12 +0100ukari(~ukari@unaffiliated/ukari) (Remote host closed the connection)
2021-02-03 22:47:25 +0100 <merijn> Even easier
2021-02-03 22:47:29 +0100 <ij> ah, in light of recursion, sure
2021-02-03 22:47:36 +0100 <merijn> Consider: "length (repeat 1)"
2021-02-03 22:47:40 +0100 <merijn> > repeat 1
2021-02-03 22:47:42 +0100 <lambdabot> [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1...
2021-02-03 22:47:43 +0100ukari(~ukari@unaffiliated/ukari)
2021-02-03 22:47:49 +0100 <ij> > length $ repeat 1
2021-02-03 22:47:58 +0100 <lambdabot> mueval.real: ExitFailure 1
2021-02-03 22:48:00 +0100 <[exa]> oh noes
2021-02-03 22:48:10 +0100 <ij> merijn, it wouldn't work anyway – what's the difference?
2021-02-03 22:48:17 +0100 <merijn> ij: It loops infinitely
2021-02-03 22:48:25 +0100 <ij> but it doesn't crash?
2021-02-03 22:48:30 +0100 <geekosaur> head (repeat 1)
2021-02-03 22:48:32 +0100 <merijn> ij: No
2021-02-03 22:48:45 +0100 <[exa]> merijn: I wanted to have a working case for comparison :D
2021-02-03 22:48:46 +0100 <geekosaur> overstrict you hit an infinite loop
2021-02-03 22:48:57 +0100 <ij> I guess I mean stop
2021-02-03 22:49:01 +0100 <[exa]> yeah it's better with head
2021-02-03 22:49:13 +0100 <merijn> ij: In Turing complete language you can't rule out non-termination (like infinite loops), but some things that are infinite loops in a strict setting aren't in a lazy setting
2021-02-03 22:49:22 +0100 <merijn> > head $ map (+1) (repeat 1)
2021-02-03 22:49:24 +0100geekosaur(82650c7c@130.101.12.124) (Quit: Connection closed)
2021-02-03 22:49:24 +0100 <lambdabot> 2
2021-02-03 22:49:39 +0100 <merijn> ij: In a strict setting the map never terminates and that whole thing doesn't work
2021-02-03 22:49:48 +0100 <ij> gotcha
2021-02-03 22:50:06 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 256 seconds)
2021-02-03 22:50:11 +0100 <ij> makes sense when recursive defs come into play
2021-02-03 22:50:23 +0100rwdrich28(560395a9@cpc159427-cmbg20-2-0-cust424.5-4.cable.virginm.net)
2021-02-03 22:50:30 +0100geekosaur(82650c7c@130.101.12.124)
2021-02-03 22:50:34 +0100 <ij> I think I have some thunks to kill in my program
2021-02-03 22:50:46 +0100 <[exa]> ij: anyway, the final point is that the definition of WHNF (either a straightforward accessible patternmatchable data, or surely a function, or surely a builtin) kindof precisely describes the strictness problems, so haskell uses it
2021-02-03 22:50:50 +0100 <ij> -O sped it up by 5x already
2021-02-03 22:51:00 +0100swarmcollectivesees dead thunks, all the time
2021-02-03 22:51:14 +0100 <ij> [exa], alright, cool!
2021-02-03 22:51:19 +0100 <[exa]> ij: Int vs. Integer
2021-02-03 22:51:19 +0100 <[exa]> :]
2021-02-03 22:51:26 +0100 <monochrom> With lazy evaluation and conceptually infinite data (sure you'll only consume a finite prefix) you need a finer distinction than the false dichotomy "terminates" "doesn't terminate".
2021-02-03 22:51:58 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-02-03 22:52:02 +0100 <monochrom> Either that, or you have to classify "f x : map f xs" as "terminates".
2021-02-03 22:52:10 +0100 <[exa]> ij: anyway, the divergence (aka infinite loop) is one common case where you need to care about strictness, the second common case is just plain bottom (aka undefined aka exception)
2021-02-03 22:52:27 +0100 <monochrom> In fact, in that sense, "f x : map f xs" is O(1)-time.
2021-02-03 22:52:46 +0100 <ij> monochrom, wouldn't "terminates or not" be enough, if you also specify "with these semantics"?
2021-02-03 22:53:05 +0100 <monochrom> See my "or"
2021-02-03 22:54:07 +0100 <ij> you mean it depends what's around the expression/how it's used?
2021-02-03 22:54:21 +0100 <monochrom> There are many correct models that disagree on how to use terminologies.
2021-02-03 22:54:43 +0100 <monochrom> And they are equivalent after you ignore disputes on terminologies.
2021-02-03 22:55:14 +0100 <monochrom> There are people who use the word "productive, though not terminating" for "f x : map f xs".
2021-02-03 22:55:24 +0100michalz(~user@185.246.204.76) (Remote host closed the connection)
2021-02-03 22:56:16 +0100 <monochrom> They are not wrong as long as they are self-consistent and, you have to take into account the rest of their model, they still make the right predictions, e.g., "head (map f [1..]) takes as little time as [f 1]"
2021-02-03 22:56:32 +0100rwdrich28(560395a9@cpc159427-cmbg20-2-0-cust424.5-4.cable.virginm.net) (Quit: Connection closed)
2021-02-03 22:57:23 +0100 <monochrom> So I mean there are many incompatible ways of defining "terminates".
2021-02-03 22:57:32 +0100 <ij> is a thunk something that is boxed?
2021-02-03 22:57:35 +0100 <ij> "However, the parameter acc isn't strict, because there's no guarantee that the caller will evaluate it. The compiler will use a fully boxed Int to represent acc"
2021-02-03 22:58:07 +0100 <monochrom> What do you already know of "box"?
2021-02-03 22:58:30 +0100 <monochrom> Because if you don't know, then using it to explain other things is meaningful.
2021-02-03 22:58:34 +0100 <monochrom> err, meaningless.
2021-02-03 22:59:08 +0100 <ij> a box can be a pointer to the data, but I guess I don't
2021-02-03 22:59:28 +0100 <ij> is that something very internal or can I read about it?
2021-02-03 22:59:30 +0100 <monochrom> I know a lot of people preserve their Dunning-Kruger by tossing around "thunk" and "box" without knowing anything.
2021-02-03 22:59:32 +0100Varis(~Tadas@unaffiliated/varis) (Remote host closed the connection)
2021-02-03 22:59:48 +0100johnw(~johnw@haskell/developer/johnw)
2021-02-03 22:59:49 +0100 <monochrom> No, a box is what that pointer points to.
2021-02-03 23:00:27 +0100deviantfero(~deviantfe@179.51.60.188)
2021-02-03 23:00:35 +0100 <monochrom> I never use the word "box", because everyonoe already knows "heap object", and "box" means that, no more no less.
2021-02-03 23:00:38 +0100danvet(~Daniel@2a02:168:57f4:0:efd0:b9e5:5ae6:c2fa) (Ping timeout: 264 seconds)
2021-02-03 23:00:41 +0100 <ij> that makes no sense at all
2021-02-03 23:01:04 +0100 <monochrom> The only advantage of the word "box" is it mitigates RSI.
2021-02-03 23:01:40 +0100 <monochrom> But you should set up a macro in your IRC client to auto-expand "box" to "heap object". :)
2021-02-03 23:01:47 +0100kupi(uid212005@gateway/web/irccloud.com/x-hwbscpvqcraoqtak)
2021-02-03 23:01:55 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl) (Remote host closed the connection)
2021-02-03 23:01:58 +0100 <ephemient> https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/rts/storage/heap-objects
2021-02-03 23:02:09 +0100 <monochrom> A thunk is stored on the heap, so it is one of many kinds of heap objects.
2021-02-03 23:02:26 +0100 <kupi> >> is the same as *> ?
2021-02-03 23:02:38 +0100 <monochrom> But of course, as usual, a lot of people still don't know what's in a thunk.
2021-02-03 23:02:45 +0100 <ephemient> yes-ish
2021-02-03 23:02:55 +0100 <ij> monochrom, box = heap object sounds good, certainly much more straight-forward
2021-02-03 23:03:22 +0100 <monochrom> Yes for law-abiding instances. And if "same" means observationally equivalent esp. ignoring possible tiny performance differences.
2021-02-03 23:03:36 +0100 <swarmcollective> monochrom, explain RSI?
2021-02-03 23:03:57 +0100 <ij> swarmcollective, repetitive strain injury – i.e. what happens when you smash the keys all day
2021-02-03 23:04:05 +0100 <Uniaika> carpian canal?
2021-02-03 23:04:08 +0100 <monochrom> If you have fewer keys to type because the word is shorter, you don't stress your hand and wrist as much. :)
2021-02-03 23:04:10 +0100 <Uniaika> or is it different?
2021-02-03 23:04:32 +0100 <swarmcollective> ij, Ahhhh! Yes.
2021-02-03 23:04:36 +0100 <Uniaika> kupi: kinda-sorta
2021-02-03 23:04:45 +0100 <ephemient> carpal tunnel syndrome is one possible effect of RSI. there are others
2021-02-03 23:04:45 +0100 <ij> Uniaika, I think cts should be when you have a weak hand with numbness
2021-02-03 23:04:52 +0100 <Uniaika> thanks ephemient
2021-02-03 23:04:55 +0100tromp(~tromp@dhcp-077-249-230-040.chello.nl)
2021-02-03 23:04:57 +0100 <kupi> which is faster?
2021-02-03 23:05:03 +0100 <ij> ha!
2021-02-03 23:05:07 +0100 <ephemient> mu
2021-02-03 23:05:20 +0100 <Uniaika> kupi: dump the core IR :P
2021-02-03 23:05:45 +0100 <swarmcollective> box & RSI > Abbr.
2021-02-03 23:06:59 +0100geekosaur(82650c7c@130.101.12.124) (Quit: Connection closed)
2021-02-03 23:07:18 +0100 <kupi> nvm, i am still too newbie to optimize, i will stick to *> because that is more general
2021-02-03 23:07:31 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Connection closed)
2021-02-03 23:07:45 +0100 <ephemient> *> vs >> is not going to be a worthwhile optimization anyway
2021-02-03 23:07:48 +0100conal(~conal@64.71.133.70) (Read error: Connection reset by peer)
2021-02-03 23:07:52 +0100 <ij> ^
2021-02-03 23:07:53 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 23:08:56 +0100 <ij> how should I go about finding unnecessary thunks? I have a program that I'm pretty sure could have everything strict
2021-02-03 23:09:03 +0100 <ij> just add bangs everywhere?
2021-02-03 23:09:26 +0100 <merijn> "could have" is not "should"
2021-02-03 23:09:52 +0100 <monochrom> In some cases, I use >> when I'm already using >>=, I use *> when I'm already sticking to <*>.
2021-02-03 23:10:04 +0100 <monochrom> In other cases, I use *> so I don't have to teach >>
2021-02-03 23:10:12 +0100 <ij> merijn, why?
2021-02-03 23:10:28 +0100 <ephemient> there is a {-# LANGUAGE Strict #-} pragma
2021-02-03 23:10:33 +0100 <ij> because you might not need all the data, I guess
2021-02-03 23:10:52 +0100 <merijn> ij: Randomly making things strict is about as likely to make things slower as it is to make things faster
2021-02-03 23:10:52 +0100 <ephemient> although at that point I think you're working in a Haskell-like language rather than Haskell
2021-02-03 23:11:06 +0100 <merijn> There are no shortcuts that let you skip "understanding what you're doing"
2021-02-03 23:11:43 +0100swarmcollectiveavoids symbolic representations of functions, except for <$> :/ :\
2021-02-03 23:11:54 +0100 <ij> merijn, everything is strict in C. it is pretty fast
2021-02-03 23:12:07 +0100 <monochrom> I don't even worry about these things until empirically it is very pressing that the time or space cost is really unbearable.
2021-02-03 23:12:12 +0100 <ij> except for like True && println()
2021-02-03 23:12:17 +0100 <ij> I mean false
2021-02-03 23:12:25 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Ping timeout: 240 seconds)
2021-02-03 23:12:32 +0100 <monochrom> source code sanity is more important than "5% cheaper"
2021-02-03 23:12:45 +0100 <merijn> ij: C is a very different language, with a very different compiler, a very different implementation strategy
2021-02-03 23:12:56 +0100 <monochrom> well, usually anyway, I know exceptional scenerios.
2021-02-03 23:13:17 +0100conal(~conal@64.71.133.70)
2021-02-03 23:13:32 +0100 <monochrom> C is a bad example.
2021-02-03 23:13:45 +0100 <ij> I am not sure I'll gain anything by chatting in IRC
2021-02-03 23:13:55 +0100 <yushyin> :D
2021-02-03 23:13:58 +0100 <monochrom> Why don't you argue "everything is strict in bash, it is pretty fast" and shoot yourself.
2021-02-03 23:14:23 +0100 <swarmcollective> ij, gain and/or give, it is your choice.
2021-02-03 23:14:27 +0100 <ij> monochrom, what?
2021-02-03 23:14:37 +0100 <monochrom> what what?
2021-02-03 23:14:56 +0100 <monochrom> I am testing your understand of your own <ij> merijn, everything is strict in C. it is pretty fast
2021-02-03 23:15:18 +0100 <monochrom> If you really understood that argument, you would also apply it with s/C/bash/
2021-02-03 23:15:40 +0100 <ij> bash is pretty fast
2021-02-03 23:15:43 +0100 <ephemient> I'm gaining some annoyance by listening to people who appear to be failing to learn in IRC
2021-02-03 23:15:48 +0100 <ij> 🎉
2021-02-03 23:15:50 +0100 <koz_> OK, I have something like 'Gen.element [mkSome @Proxy @Bool Proxy, mkSome @Proxy @Int Proxy]. GHC complains about a kind error (expects Gen (Some @{k1} (Proxy @{k1})), actually got Gen (Some @{*} (Proxy @{*}))).
2021-02-03 23:15:53 +0100 <koz_> How do I resolve this?
2021-02-03 23:15:58 +0100 <koala_man> some things like array indices and integer expressions sometimes end up being accidentally lazily evaluated in bash
2021-02-03 23:16:08 +0100 <ij> ephemient, I am sorry for whining
2021-02-03 23:16:13 +0100 <ij> it's just a little frustratign
2021-02-03 23:17:02 +0100 <monochrom> OK, I'll stop.
2021-02-03 23:17:25 +0100 <ij> monochrom, thank you for indulging as far as you did
2021-02-03 23:18:12 +0100 <koz_> Do I need to provide a _kind_ signature for Gen in this case?
2021-02-03 23:18:17 +0100 <koz_> s/Gen/Some/
2021-02-03 23:19:04 +0100 <monochrom> Yikes, I don't even know @{*}
2021-02-03 23:19:32 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 23:19:33 +0100 <koz_> I assume that's the kind Type?
2021-02-03 23:19:42 +0100 <monochrom> Oh! That *
2021-02-03 23:19:44 +0100 <koz_> My understanding is that Some is polykinded in a way Proxy isn't?
2021-02-03 23:19:54 +0100 <koz_> Or vice versa?
2021-02-03 23:20:01 +0100 <merijn> I assume this is the kinda code that I would write if I hated myself
2021-02-03 23:20:11 +0100 <koz_> merijn: I don't have many other options.
2021-02-03 23:20:24 +0100 <koz_> Other folks insisted on a TypeApplication-driven API which I now have to write tests for.
2021-02-03 23:20:34 +0100 <koz_> I wouldn't have designed it that way, but them's the breaks.
2021-02-03 23:20:38 +0100 <merijn> koz_: I recommend flogging said people
2021-02-03 23:20:39 +0100soft-warm(4408f588@ip68-8-245-136.sd.sd.cox.net) (Quit: Connection closed)
2021-02-03 23:20:45 +0100 <koz_> merijn: Said people are paying me.
2021-02-03 23:20:45 +0100acarrico(~acarrico@dhcp-68-142-39-249.greenmountainaccess.net)
2021-02-03 23:20:49 +0100 <monochrom> Yeah Some may need a kind-polymorphic sig so things don't default to Type
2021-02-03 23:20:54 +0100 <merijn> Doesn't change my advice :)
2021-02-03 23:20:59 +0100 <merijn> In fact
2021-02-03 23:21:01 +0100 <koz_> monochrom: How do I provide that in this context?
2021-02-03 23:21:13 +0100 <merijn> If they're paying you I'd recommend even *worse* punishment
2021-02-03 23:21:17 +0100shush(~pawn@2603-8000-3703-51f4-217f-fa24-0553-46d3.res6.spectrum.com) (Remote host closed the connection)
2021-02-03 23:21:25 +0100 <monochrom> I don't know. I'm new to this using @ for kinds.
2021-02-03 23:21:47 +0100 <ephemient> I don't know if it would make a difference, but `[mkSome (Proxy @Bool), mkSome (Proxy @Int)]` would be less stuttery
2021-02-03 23:21:56 +0100 <koz_> ephemient: It makes no difference.
2021-02-03 23:22:03 +0100 <koz_> That's how I spelled it originally.
2021-02-03 23:22:58 +0100 <monochrom> I think this is the watershed turning point from "I want a Haskell job" to "I don't want a Haskell job" :)
2021-02-03 23:23:17 +0100 <koz_> Oh, this is unusual for me.
2021-02-03 23:23:22 +0100lmw(95e04f63@gateway/web/thelounge/ip.149.224.79.99)
2021-02-03 23:23:23 +0100 <koz_> Mostly things tend not to be this gory.
2021-02-03 23:23:52 +0100 <ephemient> yeah I have no clue, `choose [mkSome (Proxy @Bool), mkSome (Proxy @Int)]` works for me and there really shouldn't be a difference between QuickCheck and hedgehog
2021-02-03 23:23:53 +0100 <monochrom> if "Haskell job" entails using so much DataKinds TypeApplication for a Rube Goldberg to fake dependent typing.
2021-02-03 23:24:20 +0100 <koz_> ephemient: It's in a where binding with an explicit sig of Gen (Some Proxy).
2021-02-03 23:24:22 +0100soft-warm(4408f588@ip68-8-245-136.sd.sd.cox.net)
2021-02-03 23:24:40 +0100 <monochrom> I guess in 5-10 years https://aphyr.com/posts/342-typing-the-technical-interview would be reality instead of joke.
2021-02-03 23:24:42 +0100 <koz_> monochrom: Again, it's pretty unusual for me, and I'm actually helping _eliminate_ a lot of said Rube Goldberging.
2021-02-03 23:25:06 +0100 <koz_> This is really rather exceptional, but yeah... TypeApplications-driven APIs don't make me a happy panda.
2021-02-03 23:25:32 +0100p-core(~Thunderbi@2001:718:1e03:5128:3697:eeda:19aa:8e56) (Ping timeout: 260 seconds)
2021-02-03 23:26:23 +0100 <monochrom> Actually I'm wondering about the notation @{k1} which is not simply @k1. Does the {} matter?
2021-02-03 23:26:38 +0100 <koz_> monochrom: Let me paste exact error message.
2021-02-03 23:26:54 +0100 <ij> merijn, if all your definitions are finite how could making code strict make it slower?
2021-02-03 23:27:01 +0100ADG1089__(~aditya@223.236.190.35)
2021-02-03 23:27:24 +0100 <monochrom> merijn, I agree with maerwald's assessment about blood pressure :)
2021-02-03 23:27:32 +0100 <ephemient> making && strict can make things slower too
2021-02-03 23:27:39 +0100 <monochrom> (Why are you getting yourself into these things all the time?)
2021-02-03 23:27:56 +0100 <koz_> monochrom: https://paste.tomsmeding.com/pmDDEw2Y/raw/1
2021-02-03 23:28:01 +0100 <koz_> Sorry for lack of linebreaks.
2021-02-03 23:28:18 +0100 <ij> ephemient, ah, gotcha
2021-02-03 23:28:27 +0100d3od(~nickmeno3@78-0-108-194.adsl.net.t-com.hr) (Remote host closed the connection)
2021-02-03 23:29:42 +0100 <merijn> monochrom: hmm?
2021-02-03 23:30:20 +0100 <monochrom> Getting yourself into conversations that become pointless but the negative effect is increasing stress.
2021-02-03 23:30:43 +0100 <merijn> monochrom: lol
2021-02-03 23:30:50 +0100 <merijn> I'm impervious to increased stress
2021-02-03 23:31:03 +0100 <merijn> I've been maxed out for, like, 3 months
2021-02-03 23:31:12 +0100 <monochrom> Ah OK that's true enough heh
2021-02-03 23:31:44 +0100 <monochrom> OK carry on! It's entertaining for the rest of us bystanders anyway!
2021-02-03 23:32:22 +0100 <monochrom> BTW have you ever seen ij's actual code?
2021-02-03 23:32:40 +0100 <merijn> A few weeks ago
2021-02-03 23:33:21 +0100 <zzz> what is the current recommended Natural number module?
2021-02-03 23:33:31 +0100jedws(~jedws@121.209.199.128)
2021-02-03 23:33:41 +0100 <merijn> 5? *ducks*
2021-02-03 23:34:04 +0100 <monochrom> Numeric.Natural
2021-02-03 23:34:05 +0100 <ij> monochrom, did you not like it?
2021-02-03 23:34:26 +0100miguel_clean(~Miguel@89-72-187-203.dynamic.chello.pl) (Quit: Leaving.)
2021-02-03 23:36:02 +0100Franciman(~francesco@host-95-235-155-82.retail.telecomitalia.it) (Quit: Leaving)
2021-02-03 23:36:45 +0100jedws(~jedws@121.209.199.128) (Client Quit)
2021-02-03 23:37:13 +0100 <zzz> lol thanks
2021-02-03 23:38:23 +0100dxld(~dxld@rush.pub.dxld.at)
2021-02-03 23:38:58 +0100 <koz_> monochrom: Found the solution - turn off PolyKinds.
2021-02-03 23:39:00 +0100nbloomf(~nbloomf@2600:1700:ad14:3020:8867:d061:b0e1:86b9) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2021-02-03 23:39:41 +0100 <monochrom> Hrm. That's anti-climatic.
2021-02-03 23:39:43 +0100livvy(~livvy@gateway/tor-sasl/livvy) (Quit: Network issue or system upgrade probably or maybe I'm testing a new kernel.)
2021-02-03 23:39:43 +0100 <koz_> (before you ask, no, I didn't decide on having it on by default either)
2021-02-03 23:40:06 +0100 <koz_> The thing is, if PolyKinds causes this situation, there has to be a way of resolving it surely.
2021-02-03 23:40:29 +0100 <koz_> But it turns out TypeApplications is also secretly KindApplications.
2021-02-03 23:40:41 +0100 <koz_> Some @(Type -> Type) Proxy is 100% a thing.
2021-02-03 23:41:02 +0100 <monochrom> If you turn on PolyKinds, then you have to write explicit kind sigs to assert "I really want Type, the whole Type and nothing but Type"
2021-02-03 23:41:04 +0100 <koz_> (didn't work for me, but it parses and GHC even recognizes it as a kind application)
2021-02-03 23:41:27 +0100 <koz_> monochrom: This I understand, but I've never had this kind of issue before, since I typically only deal with the kinds of type _variables_.
2021-02-03 23:41:42 +0100 <monochrom> Well yeah that one is natural in retrospect because TypeInType = KindMeansType
2021-02-03 23:42:12 +0100jedws(~jedws@121.209.199.128)
2021-02-03 23:42:27 +0100knupfer(~Thunderbi@200116b82c27b9002d81d776aa1cc87b.dip.versatel-1u1.de) (Ping timeout: 260 seconds)
2021-02-03 23:42:40 +0100 <koz_> TypeInType = EverythingIsSecretlyType
2021-02-03 23:42:51 +0100 <merijn> koz_: Well, yes
2021-02-03 23:42:54 +0100 <koz_> ZFC = everything is a set; GHC = everything is Type
2021-02-03 23:43:10 +0100 <koz_> It really is types all the way down.
2021-02-03 23:43:32 +0100 <monochrom> Nah, GHC still distinguishes types from terms.
2021-02-03 23:43:48 +0100 <monochrom> ZFC on the other hand asserts that even "elements" are sets.
2021-02-03 23:43:54 +0100 <ephemient> -XDataKinds :p
2021-02-03 23:44:17 +0100fendor_(~fendor@77.119.129.25.wireless.dyn.drei.com) (Read error: Connection reset by peer)
2021-02-03 23:44:21 +0100 <koz_> DataKinds doesn't actually unify term and type.
2021-02-03 23:44:26 +0100 <koz_> It just blindly clones upward.
2021-02-03 23:44:39 +0100royal_screwup216(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9)
2021-02-03 23:44:45 +0100royal_screwup21(52254809@gateway/web/cgi-irc/kiwiirc.com/ip.82.37.72.9) (Quit: Ping timeout (120 seconds))
2021-02-03 23:44:45 +0100lmw0(95e04f63@gateway/web/thelounge/session)
2021-02-03 23:44:45 +0100lmw0(95e04f63@gateway/web/thelounge/session) (Changing host)
2021-02-03 23:44:45 +0100lmw0(95e04f63@gateway/web/thelounge/ip.149.224.79.99)
2021-02-03 23:44:51 +0100fendor__(~fendor@77.119.129.25.wireless.dyn.drei.com)
2021-02-03 23:45:02 +0100 <ephemient> sure, that's fair...
2021-02-03 23:45:29 +0100 <koz_> Hence why singletons has to abuse type classes to their limits to achieve (something like) that.
2021-02-03 23:45:33 +0100fendor__(~fendor@77.119.129.25.wireless.dyn.drei.com) (Read error: Connection reset by peer)
2021-02-03 23:45:55 +0100lmw(95e04f63@gateway/web/thelounge/ip.149.224.79.99) (Ping timeout: 276 seconds)
2021-02-03 23:49:02 +0100 <ij> I guess it's pretty hard to ask help for something I am very much unskilled to fix
2021-02-03 23:49:28 +0100puke(~vroom@217.138.252.186) (Quit: puke)
2021-02-03 23:49:38 +0100nhs(~nhs@c-24-20-87-79.hsd1.or.comcast.net) (Ping timeout: 258 seconds)
2021-02-03 23:50:02 +0100conal(~conal@64.71.133.70) (Quit: Computer has gone to sleep.)
2021-02-03 23:50:26 +0100 <monochrom> No. It is really hard to get abstract generalized help.
2021-02-03 23:50:54 +0100 <monochrom> Many years ago on a math channel there was a "how do I solve equations?"
2021-02-03 23:51:03 +0100 <monochrom> How would you even begin?
2021-02-03 23:51:32 +0100 <monochrom> It turned out the student only needed "how do I solve the kind of linear one-unknown equations like 2x+3=5"
2021-02-03 23:51:46 +0100livvy(~livvy@gateway/tor-sasl/livvy)
2021-02-03 23:53:14 +0100puke(~vroom@217.138.252.203)
2021-02-03 23:54:44 +0100ph88_(~ph88@2a02:8109:9e00:7e5c:ade8:bbad:5afb:2c7)
2021-02-03 23:55:22 +0100lmw0(95e04f63@gateway/web/thelounge/ip.149.224.79.99) (Quit: The Lounge - https://thelounge.chat)
2021-02-03 23:58:20 +0100 <zzz> is there an alternative prelude that uses naturals instead of ints for functions like take?
2021-02-03 23:58:41 +0100 <merijn> zzz: Maybe, but you probably don't want that anyway
2021-02-03 23:58:57 +0100 <zzz> i don't?
2021-02-03 23:59:00 +0100 <ephemient> :t Data.List.genericTake
2021-02-03 23:59:01 +0100 <lambdabot> Integral i => i -> [a] -> [a]
2021-02-03 23:59:15 +0100 <merijn> I speak from experience when I say: Turns out it's *real* annoying when you gotta call "fromIntegral" on every Int you have before indexing something
2021-02-03 23:59:20 +0100 <monochrom> I think such an alternative prelude doesn't exist.