IRCBrowse

2021/12/09

2021-12-09 00:02:59 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2021-12-09 00:04:13 +0100curiousgay(~curiousga@77-120-141-90.kha.volia.net) (Ping timeout: 240 seconds)
2021-12-09 00:04:16 +0100LiaoTao(~LiaoTao@gateway/tor-sasl/liaotao) (Remote host closed the connection)
2021-12-09 00:04:34 +0100relrod_relrod
2021-12-09 00:05:33 +0100LiaoTao(~LiaoTao@gateway/tor-sasl/liaotao)
2021-12-09 00:06:33 +0100k60``(~user@static.100.218.46.78.clients.your-server.de)
2021-12-09 00:08:14 +0100smartin(~Thunderbi@88.135.18.171) (Quit: smartin)
2021-12-09 00:10:34 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-12-09 00:11:39 +0100waleee(~waleee@2001:9b0:21d:fc00:398f:b003:b90d:acf4) (Ping timeout: 265 seconds)
2021-12-09 00:12:03 +0100waleee(~waleee@h-98-128-229-110.NA.cust.bahnhof.se)
2021-12-09 00:16:46 +0100Sgeo(~Sgeo@user/sgeo)
2021-12-09 00:17:49 +0100pfurla(~pfurla@2804:14d:5c5a:9a78:840d:6ccb:3c35:c390) (Quit: gone to sleep. ZZZzzz…)
2021-12-09 00:27:48 +0100dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be) (Quit: WeeChat 3.3)
2021-12-09 00:29:45 +0100AlexNoo_(~AlexNoo@94.233.241.193)
2021-12-09 00:30:13 +0100InternetCitizen(~fuzzypixe@eth-west-pareq2-46-193-4-100.wb.wifirst.net) (Ping timeout: 240 seconds)
2021-12-09 00:32:11 +0100Alex_test(~al_test@178.34.163.11) (Ping timeout: 252 seconds)
2021-12-09 00:32:55 +0100AlexZenon(~alzenon@178.34.163.11) (Ping timeout: 252 seconds)
2021-12-09 00:33:21 +0100AlexNoo(~AlexNoo@178.34.163.11) (Ping timeout: 256 seconds)
2021-12-09 00:34:55 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 00:36:32 +0100Alex_test(~al_test@94.233.241.193)
2021-12-09 00:37:07 +0100AlexZenon(~alzenon@94.233.241.193)
2021-12-09 00:43:16 +0100pfurla(~pfurla@2804:14d:5c5a:9a78:840d:6ccb:3c35:c390)
2021-12-09 00:44:41 +0100 <dsal> One of the more expensive parts of my code is this "select" function. The good news is that if I inline it, it no longer shows up in the profile.
2021-12-09 00:44:53 +0100 <dsal> I manually wrote out what it did in my list monad and it was faster, but grosser.
2021-12-09 00:46:54 +0100 <monochrom> Good that it is actually faster.
2021-12-09 00:47:12 +0100 <monochrom> Because "doesn't show up in profiling, but just as slow" is not progress heh
2021-12-09 00:47:44 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 00:49:51 +0100zhakupov(~zhakupov@static.90.189.158.74.sinor.ru)
2021-12-09 00:51:01 +0100 <dsal> I think the inline select is a little faster. But inlining everything takes all the blame away from the little functions.
2021-12-09 00:52:04 +0100 <dsal> Doing it manually is a lot faster, but gross code. Instead of `(thing, things) <- select stuff; (nextThing, nextThings) <- select things` it's like, `thing <- stuff; let things = filter (/= thing) things`
2021-12-09 00:52:20 +0100 <dsal> (I made an operator to make that slightly better, but only slightly)
2021-12-09 00:54:40 +0100zhakupov(~zhakupov@static.90.189.158.74.sinor.ru) (Ping timeout: 265 seconds)
2021-12-09 00:55:20 +0100 <dsal> 20% of the runtime of this thing is select. Followed by making a map. I wonder if using a list instead of a map would be faster.
2021-12-09 00:58:22 +0100 <dsal> Hey neat, not making the map made that part not be hot in my profile. I should just delete all this code.
2021-12-09 00:59:06 +0100 <dsal> Woah. Yeah, not using a map is a lot faster than using a map.
2021-12-09 01:01:45 +0100superstar64(~superstar@2600:1700:ed80:50a0:d250:99ff:fe2c:53c4) (Quit: Leaving)
2021-12-09 01:02:27 +0100 <int-e> dsal: if you're just looking for brevity: `(thing, filter (/= thing) -> stuff) <- stuff` is a valid view pattern
2021-12-09 01:02:35 +0100 <georgy> dsal that is surprising. do you have a test case? are you compiling with -O2?
2021-12-09 01:02:44 +0100 <int-e> hmm
2021-12-09 01:02:56 +0100 <int-e> that is not right
2021-12-09 01:03:24 +0100 <dsal> georgy: It's not that surprising. It's a very small amount of data.
2021-12-09 01:03:27 +0100bollu(uid233390@id-233390.helmsley.irccloud.com)
2021-12-09 01:03:31 +0100 <int-e> the rhs would be zip stuff (repeat stuff) and that's pushing it from ugly to terrible :)
2021-12-09 01:03:47 +0100 <geekosaur> also lists can fuse and get big speedups
2021-12-09 01:04:18 +0100genieliu(~genieliu@111.193.167.10)
2021-12-09 01:05:16 +0100 <int-e> dsal: is using filter (/=) better than the natural select [] = []; select (x:xs) = (x,xs) : map (second (x:)) (select xs)?
2021-12-09 01:05:34 +0100 <dsal> int-e: doing that manually seemed to be.
2021-12-09 01:05:47 +0100 <dsal> "manually" -- I'm doing that several times in a list monad.
2021-12-09 01:05:53 +0100 <int-e> I guess carrying those pairs around is expensive
2021-12-09 01:06:35 +0100InternetCitizen(~fuzzypixe@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-12-09 01:09:55 +0100genieliu(~genieliu@111.193.167.10) (Quit: Lost terminal)
2021-12-09 01:13:31 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net) (Ping timeout: 265 seconds)
2021-12-09 01:15:29 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-12-09 01:15:30 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2021-12-09 01:18:51 +0100Guest|92(~Guest|92@88.98.202.129)
2021-12-09 01:19:01 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2021-12-09 01:20:55 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-12-09 01:20:55 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-12-09 01:20:55 +0100wroathe(~wroathe@user/wroathe)
2021-12-09 01:21:01 +0100alx741(~alx741@186.178.108.192) (Ping timeout: 240 seconds)
2021-12-09 01:21:44 +0100deadmarshal(~deadmarsh@95.38.228.30) (Ping timeout: 265 seconds)
2021-12-09 01:27:39 +0100max22-(~maxime@2a01cb088335980012b6a709282cc846.ipv6.abo.wanadoo.fr) (Remote host closed the connection)
2021-12-09 01:28:59 +0100jkaye(~jkaye@c-71-205-220-154.hsd1.co.comcast.net) (Ping timeout: 268 seconds)
2021-12-09 01:29:10 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net)
2021-12-09 01:30:33 +0100 <georgy> is there some unicode character similar to (:) that I can use for functions rather than just constructors?
2021-12-09 01:30:41 +0100 <georgy> s/just/only
2021-12-09 01:31:41 +0100 <geekosaur> by functions do you actually mean functions, or operators?
2021-12-09 01:32:08 +0100sprout_(~quassel@2a02:a467:ccd6:1:bc10:5f40:71cb:b3b6) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2021-12-09 01:32:17 +0100 <georgy> yeah, I meant an operator not a function
2021-12-09 01:32:22 +0100acidjnk_new(~acidjnk@p200300d0c7271e730cb547fb259b1246.dip0.t-ipconnect.de) (Ping timeout: 265 seconds)
2021-12-09 01:32:22 +0100 <hpc> there's a unicode colon lookalike that agda uses to differentiate between type signatures and its dependent sum syntax sugar, don't know what the actual character is though
2021-12-09 01:32:25 +0100 <hpc> so it exists
2021-12-09 01:32:52 +0100 <geekosaur> greek question mark? :þ
2021-12-09 01:32:55 +0100 <hpc> there are websites that index the unicode homoglyphs, you can probably find it there
2021-12-09 01:33:25 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net) (Ping timeout: 252 seconds)
2021-12-09 01:33:40 +0100 <hpc> > let x -:> y = x + y in 5 :-> 10
2021-12-09 01:33:42 +0100 <lambdabot> error:
2021-12-09 01:33:42 +0100 <lambdabot> • Data constructor not in scope: (:->) :: t0 -> t1 -> t
2021-12-09 01:33:42 +0100 <lambdabot> • Perhaps you meant one of these:
2021-12-09 01:33:45 +0100 <hpc> > let x -:> y = x + y in 5 -:> 10
2021-12-09 01:33:47 +0100 <lambdabot> 15
2021-12-09 01:33:56 +0100 <hpc> you can also put it in the middle of the operator maybe
2021-12-09 01:34:07 +0100 <georgy> yes
2021-12-09 01:34:18 +0100 <georgy> I found it, for doing something completely silly
2021-12-09 01:35:04 +0100 <georgy> https://paste.tomsmeding.com/b9QWwtTA
2021-12-09 01:35:10 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 01:39:01 +0100InternetCitizen(~fuzzypixe@eth-west-pareq2-46-193-4-100.wb.wifirst.net) (Ping timeout: 240 seconds)
2021-12-09 01:42:13 +0100Akiva(~Akiva@user/Akiva) (Ping timeout: 240 seconds)
2021-12-09 01:42:23 +0100yinzero
2021-12-09 01:43:01 +0100pfurla(~pfurla@2804:14d:5c5a:9a78:840d:6ccb:3c35:c390) (Quit: gone to sleep. ZZZzzz…)
2021-12-09 01:43:35 +0100shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net) (Remote host closed the connection)
2021-12-09 01:43:52 +0100shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net)
2021-12-09 01:45:33 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-12-09 01:46:43 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net)
2021-12-09 01:48:35 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net) (Remote host closed the connection)
2021-12-09 01:49:18 +0100fjmorazan(~quassel@user/fjmorazan) (Quit: fjmorazan)
2021-12-09 01:49:32 +0100fjmorazan(~quassel@user/fjmorazan)
2021-12-09 01:49:46 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 265 seconds)
2021-12-09 01:49:50 +0100econo(uid147250@user/econo) (Quit: Connection closed for inactivity)
2021-12-09 01:53:25 +0100Guest|92(~Guest|92@88.98.202.129) (Ping timeout: 240 seconds)
2021-12-09 01:54:16 +0100 <hololeap> is there an option for cabal to place executables in a more convenient location after running cabal build?
2021-12-09 01:55:00 +0100fjmorazan(~quassel@user/fjmorazan) (Quit: fjmorazan)
2021-12-09 01:55:15 +0100 <sclv> nope. best you can do is a “cabal install” and pass an arg for a path in that. But the semantics are different
2021-12-09 01:55:33 +0100fjmorazan(~quassel@user/fjmorazan)
2021-12-09 01:56:55 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-12-09 01:59:00 +0100 <xerox> I find myself doing cp "$(cabal list-bin Name)" . sometimes
2021-12-09 01:59:16 +0100maroloccio(~marolocci@151.53.155.184)
2021-12-09 01:59:20 +0100mvk(~mvk@2607:fea8:5cdd:f000::9788)
2021-12-09 01:59:21 +0100 <monochrom> Don't forget to also run "strip" :)
2021-12-09 01:59:34 +0100 <monochrom> "cabal install" runs strip, but "cabal build" doesn't.
2021-12-09 02:01:12 +0100 <monochrom> But "cabal list-bin" is nice, yeah.
2021-12-09 02:01:46 +0100Kevin578(~Kevin578@pool-96-237-112-198.bstnma.fios.verizon.net)
2021-12-09 02:02:13 +0100jgeerds(~jgeerds@55d4ac73.access.ecotel.net) (Ping timeout: 240 seconds)
2021-12-09 02:07:11 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-12-09 02:07:18 +0100 <hololeap> sclv, thanks, this actually works great: cabal install --install-method=symlink --installdir=./bin
2021-12-09 02:09:12 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-12-09 02:11:22 +0100 <monochrom> symlink is a very bad idea unless you never clear $HOME/.cabal/store
2021-12-09 02:12:17 +0100 <monochrom> Because the exe is stored there.
2021-12-09 02:12:32 +0100 <sclv> well sadly even copy doesn't necessarily work then if there's any attendant datafiles
2021-12-09 02:12:34 +0100 <hololeap> oh, I thought it was symlinking to the exes in the dist-newstyle dir
2021-12-09 02:13:32 +0100 <sclv> *me* shakes fist at datafiles
2021-12-09 02:13:32 +0100 <hpc> just do the windows trick and make your executable also happen to be a zip file
2021-12-09 02:13:32 +0100 <sclv> i think we can fix the datadir flags to do things right, but nobody's just worked out the details yet
2021-12-09 02:13:49 +0100mncheck(~mncheck@193.224.205.254) (Remote host closed the connection)
2021-12-09 02:13:52 +0100 <geekosaur> people have iirc been trying to work out those details for years, because they also have to work after cabal build
2021-12-09 02:14:03 +0100 <sclv> i mean there's years old tickets
2021-12-09 02:14:06 +0100mncheck(~mncheck@193.224.205.254)
2021-12-09 02:14:23 +0100 <sclv> no Very Smart Person has sat down and just given a full answer to "here's what to do that's flexible enough for all circumstances"
2021-12-09 02:15:15 +0100 <sclv> like imho there's not even failed attempts that actually began from the full problem space -- just proposals that didn't take enough into account, and when people pointed out it was harder, people wandered off to worry about other things
2021-12-09 02:15:29 +0100 <sclv> i.e. i don't think its too hard to solve. it just hasn't had the right sustained attention
2021-12-09 02:16:02 +0100Neuromancer(~Neuromanc@user/neuromancer) (Ping timeout: 240 seconds)
2021-12-09 02:20:16 +0100mikoto-chan(~mikoto-ch@esm-84-240-99-143.netplaza.fi)
2021-12-09 02:21:49 +0100myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net) (Ping timeout: 252 seconds)
2021-12-09 02:22:13 +0100jj(~jj@bras-base-stcton1104w-grc-60-69-159-29-115.dsl.bell.ca)
2021-12-09 02:23:19 +0100jj(~jj@bras-base-stcton1104w-grc-60-69-159-29-115.dsl.bell.ca) ()
2021-12-09 02:23:35 +0100 <dsal> link hard or link $HOME
2021-12-09 02:26:37 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Ping timeout: 240 seconds)
2021-12-09 02:27:35 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-12-09 02:27:35 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-12-09 02:27:35 +0100wroathe(~wroathe@user/wroathe)
2021-12-09 02:30:51 +0100 <sm> just embed them
2021-12-09 02:34:28 +0100 <oats> finally got day 8 https://github.com/oatberry/aoc2021-haskell/blob/main/src/Day8.hs
2021-12-09 02:34:49 +0100 <oats> I bet there's a better way to have done this, but I figured out an algo for deducing segment assignments
2021-12-09 02:35:41 +0100 <dsal> I found it was *significantly* faster to use `[(Char, Char)]` instead of `Map Char Char`
2021-12-09 02:36:11 +0100 <oats> dsal, what does your `Map Char Char` represent
2021-12-09 02:36:55 +0100 <dsal> The observed wire to the wire where it's supposed to be according to the diagram.
2021-12-09 02:37:11 +0100 <oats> huh
2021-12-09 02:37:13 +0100 <georgy> dsal, how many elements do you have?
2021-12-09 02:37:13 +0100 <dsal> Oh, you had a `Segment`
2021-12-09 02:37:19 +0100 <dsal> georgy: 7
2021-12-09 02:37:29 +0100 <georgy> that's not surprising
2021-12-09 02:38:11 +0100 <oats> I had a hunch that some set operations might be useful, but it took some guesswork to tease out exactly what I had to do
2021-12-09 02:38:12 +0100 <georgy> I did tests a couple of years ago, and IIRC Map starts becoming faster when you have a couple of hundred elements. and it only gets worse from there. O(n) vs log(n)
2021-12-09 02:39:02 +0100 <georgy> basically.. list is only faster when the speed likely doesn't matter at all
2021-12-09 02:39:41 +0100 <dsal> Speed's mattering a lot to me.
2021-12-09 02:40:08 +0100 <monochrom> "Each dictionary has size 5 but I have 10^10 such dictionaries" may favour a low-tech way.
2021-12-09 02:40:12 +0100 <georgy> when looking up an element in a 7 element collection?
2021-12-09 02:42:21 +0100 <monochrom> Or "I have to perform 10^10 lookups"
2021-12-09 02:42:29 +0100 <oats> dsal, ah yeah, my solution solves the big boy in about 10 seconds :P
2021-12-09 02:42:33 +0100 <georgy> monochrom, that sounds as contrived as your first example
2021-12-09 02:43:20 +0100 <dsal> oats: I'm trying to get below a second on my macbook, but it's a pretty bad place to benchmark I've found. heh
2021-12-09 02:44:01 +0100 <dsal> Currently at 1.103 s
2021-12-09 02:44:21 +0100 <monochrom> Well, all of AoC is contrived. There.
2021-12-09 02:45:54 +0100 <dsal> These are real problems. If we don't get this done, Santa's not going to deliver presents.
2021-12-09 02:46:20 +0100 <oats> I should try to find a way to figure the numbers straight from the scrambled input, without trying to calculate mappings
2021-12-09 02:46:24 +0100 <oats> wonder if that's possible...
2021-12-09 02:47:19 +0100 <dsal> I wouldn't think so... the mappings tell you which things are on.
2021-12-09 02:47:22 +0100lbseale(~ep1ctetus@user/ep1ctetus) (Read error: Connection reset by peer)
2021-12-09 02:48:32 +0100 <oats> but I mean, I wonder if you could use the set relationships between them to figure out a direct mapping from scrambled LED to number
2021-12-09 02:48:41 +0100 <xerox> mine takes 2.018 s ± 0.011 s over 20 runs
2021-12-09 02:49:26 +0100burnsidesLlama(~burnsides@dhcp168-017.wadham.ox.ac.uk) (Remote host closed the connection)
2021-12-09 02:50:02 +0100burnsidesLlama(~burnsides@client-8-73.eduroam.oxuni.org.uk)
2021-12-09 02:50:15 +0100 <oats> dsal, such as, I believe the digit '3' one can be found
2021-12-09 02:50:32 +0100 <oats> by looking for the one that contains all the segments from '1' plus three others
2021-12-09 02:50:58 +0100 <dsal> Sure, you can hone your search strategy.
2021-12-09 02:51:18 +0100 <xerox> this one is p slick https://i.redd.it/bkktn06kud481.jpg
2021-12-09 02:51:52 +0100 <oats> yeah that's exactly what I'm talking about 'ere
2021-12-09 02:52:02 +0100 <oats> grrr now I gotta go rewrite my solution
2021-12-09 02:52:07 +0100 <xerox> haha
2021-12-09 02:53:32 +0100 <oats> I'm still proud of my candidate whittling :<
2021-12-09 02:54:31 +0100 <dsal> Yeah, sure. You use that to figure out how to search. You can know that the two digit one is the number 1 and that the three digit one is the number seven and has to have two elements in common with 1.
2021-12-09 02:54:32 +0100burnsidesLlama(~burnsides@client-8-73.eduroam.oxuni.org.uk) (Ping timeout: 256 seconds)
2021-12-09 02:54:38 +0100nebu(~user@user/wavion)
2021-12-09 02:54:53 +0100 <dsal> Here's another fun thing you can know: what segments e, b, and f are without searching.
2021-12-09 02:55:29 +0100 <dsal> I only end up searching for c, a, and d.
2021-12-09 02:55:42 +0100 <dsal> (g is the one that isn't any of those other ones)
2021-12-09 02:56:35 +0100polezaivsani(~polezaivs@orangeshoelaces.net) (Quit: rcirc on GNU Emacs 27.2)
2021-12-09 02:58:11 +0100Feuermagier(~Feuermagi@user/feuermagier) (Remote host closed the connection)
2021-12-09 02:58:26 +0100Feuermagier(~Feuermagi@user/feuermagier)
2021-12-09 02:58:37 +0100teo(~teo@user/teo) (Ping timeout: 240 seconds)
2021-12-09 03:01:52 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-12-09 03:07:59 +0100jeetelongnameyeet
2021-12-09 03:08:28 +0100yeetjeetelongname
2021-12-09 03:09:01 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 240 seconds)
2021-12-09 03:09:55 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 03:10:13 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 03:10:20 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 03:10:38 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 03:10:45 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 03:11:49 +0100mmhat(~mmh@55d44a9c.access.ecotel.net) (Ping timeout: 240 seconds)
2021-12-09 03:12:03 +0100xff0x(~xff0x@2001:1a81:52f0:d600:cda8:efb:cccc:cf1c) (Ping timeout: 252 seconds)
2021-12-09 03:13:14 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2021-12-09 03:13:49 +0100xff0x(~xff0x@2001:1a81:5338:9c00:c94e:b6de:b30e:1ff8)
2021-12-09 03:14:36 +0100vicfred(~vicfred@user/vicfred) (Quit: Leaving)
2021-12-09 03:15:44 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-12-09 03:16:09 +0100pfurla(~pfurla@2804:14d:5c81:4104:e550:12e4:9dfb:af3c)
2021-12-09 03:16:46 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 265 seconds)
2021-12-09 03:18:12 +0100xkuru(~xkuru@user/xkuru) (Read error: Connection reset by peer)
2021-12-09 03:33:53 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-12-09 03:33:53 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-12-09 03:33:53 +0100wroathe(~wroathe@user/wroathe)
2021-12-09 03:34:25 +0100cheater(~Username@user/cheater) (Ping timeout: 252 seconds)
2021-12-09 03:34:46 +0100 <hololeap> this was a fun piece of a solution for AoC day 4: boards = Ap . Compose . ZipList . repeat
2021-12-09 03:34:57 +0100cheater(~Username@user/cheater)
2021-12-09 03:37:21 +0100mvk(~mvk@2607:fea8:5cdd:f000::9788) (Ping timeout: 252 seconds)
2021-12-09 03:38:13 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2021-12-09 03:40:57 +0100 <hololeap> type Boards = Ap (Compose ZipList Board)
2021-12-09 03:41:07 +0100 <hololeap> runBoards :: Boards a -> ZipList (BoardState -> (Maybe (a, BoardState), BoardLog))
2021-12-09 03:41:22 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 03:42:40 +0100 <hololeap> so you can use a ZipList of the initial BoardStates to run it, using ZipList's Applicative instnace
2021-12-09 03:45:16 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Ping timeout: 268 seconds)
2021-12-09 03:46:12 +0100 <dsal> Still a mystery to me how it doesn't seem to parallelize at all.
2021-12-09 03:46:15 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 265 seconds)
2021-12-09 03:47:45 +0100 <dsal> turning up the spark limit still doubles my CPU consumption, but also doubles the runtime.
2021-12-09 03:47:57 +0100 <dsal> computer sparks up and everything seems to slow down
2021-12-09 03:49:09 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net)
2021-12-09 03:49:21 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-12-09 03:49:46 +0100 <monochrom> If you haven't had supper, this is a good time to make a grilled cheese sandwich with your benchmarking!
2021-12-09 03:50:11 +0100 <dsal> ha. Yeah. I've been benchmarking all kinds of dumb things.
2021-12-09 03:50:40 +0100 <dsal> Here's what I've learned, everyone: Lists are faster than maps. Parallelism is the same speed as sequential processing.
2021-12-09 03:51:06 +0100 <dsal> If you're tired of seeing something show up in your profile, inline it and you'll stop seeing its name.
2021-12-09 03:51:40 +0100 <monochrom> Use an older computer for higher performance.
2021-12-09 03:51:47 +0100 <dsal> Yes.
2021-12-09 03:52:10 +0100 <dsal> On my last benchmark run, my thinkpad and fancy new macbook gave me very similar numbers.
2021-12-09 03:52:20 +0100Erutuon(~Erutuon@user/erutuon) (Ping timeout: 256 seconds)
2021-12-09 03:52:43 +0100 <dsal> about 1.1 seconds ± 500ms
2021-12-09 03:53:59 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net) (Ping timeout: 265 seconds)
2021-12-09 03:54:01 +0100Erutuon(~Erutuon@user/erutuon)
2021-12-09 03:54:48 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 03:55:24 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-12-09 03:56:24 +0100jeetelongname(~jeet@148.197.248.50) (Quit: thanks!)
2021-12-09 03:57:11 +0100jeetelongname(~jeet@148.197.248.50)
2021-12-09 03:59:18 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 265 seconds)
2021-12-09 04:01:58 +0100user0(~aj@langw.roketelkom.co.ug)
2021-12-09 04:05:54 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 04:07:13 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-12-09 04:08:08 +0100Cajun(~Cajun@user/cajun)
2021-12-09 04:13:41 +0100 <hololeap> I'm on day 6 now. the second part trashed my naive algorithm using the Monad instance for Data.Vector. I'm thinking about using Data.Vector.Unboxed.Mutable instead, but I'm not sure exactly how that will speed things up
2021-12-09 04:16:53 +0100 <hololeap> for instance, when a new fish is spawned, the vector will need to grow somehow, but is that really going to be any faster using the mutable interface vs the immutable interface? will the ability to change values in-place be faster than folding over an immutable vector and building up a new one?
2021-12-09 04:16:57 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2021-12-09 04:16:57 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2021-12-09 04:16:57 +0100finn_elijaFinnElija
2021-12-09 04:17:28 +0100 <dsal> I used a list for part 1 and it was easy.
2021-12-09 04:17:35 +0100 <hololeap> oh, snap I just realized a much better way to model this
2021-12-09 04:18:19 +0100motherfsck(~motherfsc@user/motherfsck) (Quit: quit)
2021-12-09 04:18:31 +0100 <hololeap> I can just group all the fish with the same number together
2021-12-09 04:31:01 +0100td_(~td@94.134.91.212) (Ping timeout: 240 seconds)
2021-12-09 04:31:04 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 04:33:15 +0100td_(~td@muedsl-82-207-238-085.citykom.de)
2021-12-09 04:33:45 +0100myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net)
2021-12-09 04:35:14 +0100 <byorgey> hololeap: there you go =)
2021-12-09 04:35:49 +0100xff0x(~xff0x@2001:1a81:5338:9c00:c94e:b6de:b30e:1ff8) (Ping timeout: 240 seconds)
2021-12-09 04:36:59 +0100xff0x(~xff0x@2001:1a81:5338:9c00:5f64:a7ee:3eb7:fd11)
2021-12-09 04:39:49 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-12-09 04:43:24 +0100nattiestnate(~nate@2001:448a:20a0:4134:25e:715f:d637:5263) (Quit: WeeChat 3.3)
2021-12-09 04:46:04 +0100zhakupov(~zhakupov@static.90.189.158.74.sinor.ru)
2021-12-09 04:46:59 +0100 <hololeap> that would have been fun calculating a vector with 1.7 trillion elements :p
2021-12-09 04:46:59 +0100 <jeetelongname> once i got that little bit of insight the problem collapses into place
2021-12-09 04:47:23 +0100 <jeetelongname> its pretty nice in that regart
2021-12-09 04:47:43 +0100 <jeetelongname> *regard
2021-12-09 04:50:37 +0100zhakupov(~zhakupov@static.90.189.158.74.sinor.ru) (Ping timeout: 240 seconds)
2021-12-09 04:51:52 +0100 <hololeap> I could have put my RAID to work as swap
2021-12-09 04:53:54 +0100myShoggoth(~myShoggot@97-120-85-195.ptld.qwest.net) (Quit: Leaving)
2021-12-09 04:54:01 +0100dwt_(~dwt_@c-98-200-58-177.hsd1.tx.comcast.net) (Ping timeout: 256 seconds)
2021-12-09 05:01:40 +0100 <jeetelongname> I mean thats the baller way to do it but most of us don't have servers to offload aoc questions onto lol
2021-12-09 05:06:00 +0100ProfSimm(~ProfSimm@87.227.196.109)
2021-12-09 05:07:48 +0100 <ProfSimm> Hi
2021-12-09 05:08:27 +0100dwt_(~dwt_@c-98-200-58-177.hsd1.tx.comcast.net)
2021-12-09 05:09:48 +0100jeetelongname(~jeet@148.197.248.50) (Remote host closed the connection)
2021-12-09 05:11:09 +0100 <dmj`> ProfSimm: hi
2021-12-09 05:12:37 +0100Guest40(~Guest40@ec2-54-215-90-243.us-west-1.compute.amazonaws.com) (Quit: Client closed)
2021-12-09 05:14:07 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-12-09 05:15:01 +0100shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net) (Ping timeout: 240 seconds)
2021-12-09 05:19:18 +0100iteratee_(~kyle@162.218.222.107) (Read error: Connection reset by peer)
2021-12-09 05:19:26 +0100iteratee(~kyle@162.218.222.107)
2021-12-09 05:21:10 +0100zhakupov(~zhakupov@static.90.189.158.74.sinor.ru)
2021-12-09 05:25:49 +0100ProfSimm(~ProfSimm@87.227.196.109) (Ping timeout: 265 seconds)
2021-12-09 05:34:08 +0100shriekingnoise(~shrieking@186.137.144.80) (Quit: Quit)
2021-12-09 05:35:58 +0100 <jackdk> dmj`: scared him off?
2021-12-09 05:37:49 +0100pavonia(~user@user/siracusa) (Ping timeout: 240 seconds)
2021-12-09 05:40:20 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net)
2021-12-09 05:43:19 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-12-09 05:43:20 +0100 <dmj`> jackdk: yea
2021-12-09 05:43:23 +0100 <dmj`> :(
2021-12-09 05:43:30 +0100 <jackdk> :(
2021-12-09 05:43:49 +0100ProfSimm(~ProfSimm@87.227.196.109)
2021-12-09 05:45:47 +0100mbuf(~Shakthi@122.178.122.215)
2021-12-09 05:47:28 +0100 <int-e> that was some excellent timing
2021-12-09 05:49:19 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2021-12-09 05:50:20 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Remote host closed the connection)
2021-12-09 05:51:28 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-12-09 05:52:56 +0100 <jackdk> dmj`: try again
2021-12-09 05:53:14 +0100 <jackdk> ProfSimm: Hi
2021-12-09 05:53:20 +0100 <dmj`> ProfSimm: hey !
2021-12-09 05:53:51 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 265 seconds)
2021-12-09 05:54:51 +0100emf_(~emf@2620:10d:c091:480::1:7b30) (Ping timeout: 252 seconds)
2021-12-09 05:57:44 +0100curiousgay(~curiousga@77-120-141-90.kha.volia.net)
2021-12-09 05:57:56 +0100slowButPresent(~slowButPr@user/slowbutpresent) (Quit: leaving)
2021-12-09 06:05:18 +0100ProfSimm(~ProfSimm@87.227.196.109) (Remote host closed the connection)
2021-12-09 06:08:13 +0100zhakupov(~zhakupov@static.90.189.158.74.sinor.ru) (Ping timeout: 240 seconds)
2021-12-09 06:08:21 +0100LiaoTao(~LiaoTao@gateway/tor-sasl/liaotao) (Remote host closed the connection)
2021-12-09 06:08:34 +0100LiaoTao(~LiaoTao@gateway/tor-sasl/liaotao)
2021-12-09 06:09:04 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 06:13:15 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 06:18:06 +0100pfurla(~pfurla@2804:14d:5c81:4104:e550:12e4:9dfb:af3c) (Quit: gone to sleep. ZZZzzz…)
2021-12-09 06:21:13 +0100img(~img@user/img) (Quit: ZNC 1.8.2 - https://znc.in)
2021-12-09 06:23:48 +0100zhakupov(~zhakupov@static.90.189.158.74.sinor.ru)
2021-12-09 06:28:48 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-12-09 06:35:01 +0100zhakupov(~zhakupov@static.90.189.158.74.sinor.ru) (Quit: WeeChat 3.3)
2021-12-09 06:38:02 +0100img(~img@user/img)
2021-12-09 06:39:12 +0100georgy(~bc8165b6@cerf.good1.com) (Quit: CGI:IRC (EOF))
2021-12-09 06:41:55 +0100emf(~emf@2620:10d:c091:480::1:f5cb)
2021-12-09 06:47:30 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-12-09 06:52:03 +0100nfd(~nfd@user/nfd) (Ping timeout: 252 seconds)
2021-12-09 06:58:52 +0100 <hololeap> is this possible without sharing answers? https://adventofcode.com/2021/leaderboard/day/9
2021-12-09 06:59:06 +0100 <hololeap> all 100 between 5 and 11 minutes
2021-12-09 06:59:14 +0100 <hololeap> rhetorical question...
2021-12-09 07:00:56 +0100 <int-e> Well, yes it is.
2021-12-09 07:01:56 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-12-09 07:02:28 +0100 <dsal> hololeap: part of it is just having a toolkit with all the things.
2021-12-09 07:03:11 +0100 <hololeap> it just seems... rediculous. I didn't even open it up until 10 minutes in so I had failed the leaderboards already
2021-12-09 07:04:19 +0100 <hololeap> I guess I won't be getting competitive with AoC
2021-12-09 07:04:30 +0100 <int-e> There are thousands of participants, and only 600 seconds in 10 minutes.
2021-12-09 07:06:34 +0100 <hololeap> so if you can't complete part 1 and part 2 by 10:00 you have lost... it's just a bit shocking that people can code that quickly
2021-12-09 07:06:44 +0100 <int-e> You're looking at something like the lower tail of a normal distribution (just for intuition, the actual distribution is bound to be something way more complicated)
2021-12-09 07:07:52 +0100 <dsal> hololeap: The trick is to get a private leaderboard without professional competitive programmers. :)
2021-12-09 07:08:11 +0100 <xerox> works wonders for your self esteem
2021-12-09 07:10:23 +0100 <fizbin> Is anyone using stack to manage their advent-of-code stuff? I can't figure out how to have stack include an external module.
2021-12-09 07:10:52 +0100 <hololeap> I wonder if there's a twitch stream or something for some of the people on the leaderboard. I would be interested in seeing how someone writes something that quickly.
2021-12-09 07:11:32 +0100jchia[m](~jchiamatr@2001:470:69fc:105::c50b) (Quit: Client limit exceeded: 20000)
2021-12-09 07:11:50 +0100 <dsal> fizbin: I use stack. what problem are you having?
2021-12-09 07:12:02 +0100jchia[m](~jchiamatr@2001:470:69fc:105::c50b)
2021-12-09 07:12:41 +0100 <fizbin> I've got a flat directory layout (i.e. just a dir. with files like "aoc1.hs", "aoc2.hs", etc. in it) and a stack.yaml file generated by "stack init". I've mentioned the dependency in a package.yaml file, but stack says "Could not find module" when I do "stack ghc aoc9.hs"
2021-12-09 07:14:55 +0100 <dsal> That's kind of a weird way to use stack.
2021-12-09 07:15:27 +0100 <dsal> 'stack new' usually creates a project with a src directory and main and stuff.
2021-12-09 07:16:30 +0100 <fizbin> Right, which makes haskell the weird odd language where you can't just write the source but need its own directory structure. (I mainly solve these in python, then write the haskell solutions later)
2021-12-09 07:17:15 +0100 <int-e> runhaskell foo.hs < input
2021-12-09 07:17:25 +0100 <int-e> don't involve stack or cabal, be happy :-P
2021-12-09 07:17:43 +0100 <fizbin> int-e: That's what I'm trying to do, but now do that with an external package.
2021-12-09 07:18:20 +0100 <int-e> well, I have not run into that (but cabal v1-install still works for me if that comes up)
2021-12-09 07:18:44 +0100 <fizbin> Huh. It looks like package.yaml isn't getting read at all. I wonder if I need something in stack.yaml to tell it to use package.yaml
2021-12-09 07:18:55 +0100kimjetwav(~user@2607:fea8:2363:8f00:788b:37b5:7592:32b4) (Remote host closed the connection)
2021-12-09 07:20:51 +0100 <fizbin> Well, adding "." to packages in stack.yaml caused it to notice the parse error I added to package.yaml. Still doesn't seem to make it load the dependencies though.
2021-12-09 07:28:08 +0100 <fizbin> Okay, adding more than just "dependencies" to the package.yaml file (i.e. adding an "executable" section) seems to be enough so that now "stack runghc aoc9.hs" will load the external library dep. I asked for.
2021-12-09 07:29:58 +0100 <byorgey> hololeap: some of them might record themselves and post it later I guess, but you're not supposed to stream yourself solving AoC problems right when they are posted
2021-12-09 07:30:15 +0100 <byorgey> hololeap: but you can definitely find top competitive programmers streaming.
2021-12-09 07:30:20 +0100 <byorgey> in general I mean
2021-12-09 07:31:07 +0100 <byorgey> hololeap: e.g. https://www.twitch.tv/ecnerwala
2021-12-09 07:31:58 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 265 seconds)
2021-12-09 07:32:22 +0100chomwitt(~chomwitt@2a02:587:dc0d:3700:12c3:7bff:fe6d:d374)
2021-12-09 07:32:55 +0100zebrag(~chris@user/zebrag)
2021-12-09 07:33:13 +0100zebrag(~chris@user/zebrag) (Client Quit)
2021-12-09 07:35:53 +0100bollu(uid233390@id-233390.helmsley.irccloud.com) (Quit: Connection closed for inactivity)
2021-12-09 07:36:26 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2021-12-09 07:38:24 +0100 <int-e> dsal: "professional competitive programmers" -- sounds like a joke but I guess when you start automating fetching the problem and input, extracting sample, maybe generating a parser for the input... that will really feel professional.
2021-12-09 07:39:17 +0100 <int-e> (that's on top of the obvious... keeping a library for common computational tasks)
2021-12-09 07:40:37 +0100 <dsal> I do have The Library. It's not huge, though.
2021-12-09 07:41:28 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-12-09 07:41:30 +0100jakalx(~jakalx@base.jakalx.net)
2021-12-09 07:42:16 +0100 <dsal> fizbin: I don't think it's particularly special. If I want to add a python library, I have to either figure out how to get it working in nix, figure out virtualenv again, convince it to install globally for just me, or give it root access. I used to write a lot of go which had its special directory structure and stuff. Everything has an easy path that might not be what you're used to.
2021-12-09 07:46:00 +0100monochrom(trebla@216.138.220.146) (Quit: NO CARRIER)
2021-12-09 07:47:00 +0100retroid_(~retro@05412d78.skybroadband.com) (Ping timeout: 268 seconds)
2021-12-09 07:47:12 +0100 <int-e> dsal: I've yet to come up with something obviously reusable :P (in 2019 I had a "library" that consisted of an IntCode module that I'd copy to the next day's folder and adapt as needed)
2021-12-09 07:49:28 +0100euandreh(~euandreh@2804:14c:33:9fe5:da4:9ec6:5ef5:74d6) (Ping timeout: 268 seconds)
2021-12-09 07:50:56 +0100 <sm> fizbin, why not use a stack script, fewer moving parts
2021-12-09 07:51:00 +0100 <dsal> I pretty much have the same parseFile thing and some basic 2D stuff like around and a bfs.
2021-12-09 07:51:13 +0100 <dsal> The Data.Graph API is so weird.
2021-12-09 07:51:30 +0100 <int-e> dsal: true
2021-12-09 07:52:29 +0100 <int-e> bfs is so easy to implement from scratch though
2021-12-09 07:52:56 +0100 <dsal> It would've cost me precious time today! :)
2021-12-09 07:53:25 +0100 <int-e> dfs is even easier :P
2021-12-09 07:53:28 +0100 <dsal> Oh also, I had this thing: parseGrid f = Map.fromList . zipWith2D (\x y a -> ((x,y), f a)) [0..] [0..] . lines
2021-12-09 07:53:42 +0100 <xerox> bfs was easy to implement a month ago and put into my library too :D
2021-12-09 07:53:55 +0100 <dsal> Which was basically how to read this. I always got my x and y confused when I'd write those from scratch.
2021-12-09 07:54:10 +0100 <dsal> Another neat thing I wrote in my library was BitSet. Which I use occasionally.
2021-12-09 07:54:35 +0100 <dsal> It doesn't actually *matter*, but it's neat. For yesterday's, I was able to shove each of the light 7 seg patterns into a byte.
2021-12-09 07:54:46 +0100 <int-e> dsal: Hah I used [[Int]] and !!
2021-12-09 07:54:48 +0100 <int-e> KISS!
2021-12-09 07:55:24 +0100 <dsal> I've got some visualization junk I've not used this year. e.g., draw the map from today.
2021-12-09 07:55:30 +0100 <xerox> I used [String] and elemIndex
2021-12-09 07:56:08 +0100 <xerox> int-e: you haven't posted yours on github right?
2021-12-09 07:56:13 +0100 <int-e> > map (read . return) "0329" :: [Int]
2021-12-09 07:56:14 +0100 <lambdabot> [0,3,2,9]
2021-12-09 07:56:20 +0100 <int-e> xerox: right
2021-12-09 07:56:43 +0100 <xerox> if you do I would happily read them
2021-12-09 07:58:23 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2021-12-09 07:58:46 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2021-12-09 08:04:22 +0100 <dsal> > map digitToInt "0329"
2021-12-09 08:04:23 +0100 <lambdabot> [0,3,2,9]
2021-12-09 08:04:41 +0100retroid_(~retro@05412d78.skybroadband.com)
2021-12-09 08:04:54 +0100dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-12-09 08:05:00 +0100 <dsal> My fancy thing has a Char -> a because there's been a bunch of these. It doesn't have a filter, though, which would be nice.
2021-12-09 08:05:09 +0100 <dsal> I guess I could just do Maybe Int and then sequence it.
2021-12-09 08:05:14 +0100 <dsal> er, no, not that.
2021-12-09 08:06:13 +0100xff0x(~xff0x@2001:1a81:5338:9c00:5f64:a7ee:3eb7:fd11) (Ping timeout: 240 seconds)
2021-12-09 08:07:10 +0100xff0x(~xff0x@2001:1a81:5338:9c00:2366:f1e5:f2a7:3295)
2021-12-09 08:07:45 +0100InternetCitizen(~fuzzypixe@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-12-09 08:08:51 +0100Alex_test_(~al_test@94.233.241.193)
2021-12-09 08:10:04 +0100xsarnik9(xsarnik@lounge.fi.muni.cz)
2021-12-09 08:10:10 +0100Alex_test(~al_test@94.233.241.193) (Ping timeout: 256 seconds)
2021-12-09 08:10:15 +0100xstill-9(xstill@fimu/xstill)
2021-12-09 08:10:26 +0100dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 268 seconds)
2021-12-09 08:10:45 +0100koz(~koz@121.99.240.58) (Remote host closed the connection)
2021-12-09 08:11:02 +0100koz(~koz@121.99.240.58)
2021-12-09 08:11:14 +0100 <int-e> xerox: I'll think about it, I probably won't though.
2021-12-09 08:11:45 +0100Unode_(~Unode@194.94.44.220)
2021-12-09 08:11:49 +0100InternetCitizen(~fuzzypixe@eth-west-pareq2-46-193-4-100.wb.wifirst.net) (Ping timeout: 240 seconds)
2021-12-09 08:11:52 +0100xstill-(xstill@fimu/xstill) (Ping timeout: 256 seconds)
2021-12-09 08:11:52 +0100tv(~tv@user/tv) (Ping timeout: 256 seconds)
2021-12-09 08:11:52 +0100noctux(~noctux@user/noctux) (Ping timeout: 256 seconds)
2021-12-09 08:11:52 +0100sweater(~sweater@206.81.18.26) (Ping timeout: 256 seconds)
2021-12-09 08:11:52 +0100m1dnight_(~christoph@christophe.dev) (Ping timeout: 256 seconds)
2021-12-09 08:11:52 +0100davl_(~davl@207.154.228.18) (Ping timeout: 256 seconds)
2021-12-09 08:11:52 +0100turlando(~turlando@user/turlando) (Ping timeout: 256 seconds)
2021-12-09 08:11:52 +0100rookie101(~rookie@165.232.121.13) (Ping timeout: 256 seconds)
2021-12-09 08:11:52 +0100WhateverRabbit(~rabbit@206.81.18.26) (Ping timeout: 256 seconds)
2021-12-09 08:11:52 +0100xstill-9xstill-
2021-12-09 08:11:57 +0100davl(~davl@207.154.228.18)
2021-12-09 08:11:59 +0100bgamari(~bgamari@2001:470:e438::1) (Ping timeout: 252 seconds)
2021-12-09 08:12:26 +0100n3t(n3t@user/n3t) (Ping timeout: 256 seconds)
2021-12-09 08:12:26 +0100xsarnik(xsarnik@lounge.fi.muni.cz) (Ping timeout: 256 seconds)
2021-12-09 08:12:26 +0100Unode(~Unode@194.94.44.220) (Ping timeout: 256 seconds)
2021-12-09 08:12:26 +0100Unode_Unode
2021-12-09 08:12:26 +0100xsarnik9xsarnik
2021-12-09 08:12:53 +0100turlando(~turlando@93-42-250-112.ip89.fastwebnet.it)
2021-12-09 08:12:53 +0100turlando(~turlando@93-42-250-112.ip89.fastwebnet.it) (Changing host)
2021-12-09 08:12:53 +0100turlando(~turlando@user/turlando)
2021-12-09 08:13:02 +0100monochrom(trebla@216.138.220.146)
2021-12-09 08:13:31 +0100WhateverRabbit(~rabbit@206.81.18.26)
2021-12-09 08:13:51 +0100sweater(~sweater@206.81.18.26)
2021-12-09 08:14:01 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net) (Remote host closed the connection)
2021-12-09 08:14:26 +0100noctux(~noctux@user/noctux)
2021-12-09 08:14:47 +0100n3t(n3t@s45.mydevil.net)
2021-12-09 08:15:16 +0100bgamari(~bgamari@64.223.235.131)
2021-12-09 08:15:29 +0100 <hololeap> byorgey: thanks for the link
2021-12-09 08:15:42 +0100 <xerox> int-e: cool, thanks, in case :-)
2021-12-09 08:18:41 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com)
2021-12-09 08:21:17 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:48df:3af4:d67f:b5a0)
2021-12-09 08:22:07 +0100dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be)
2021-12-09 08:22:17 +0100 <hololeap> i'm looking at recording the state of a StateT with every "step". is there a way to do this without adding a (Writer (DList s)) to the transformer stack?
2021-12-09 08:22:44 +0100kozko
2021-12-09 08:22:46 +0100kokoz
2021-12-09 08:23:20 +0100michalz(~michalz@185.246.204.55)
2021-12-09 08:25:43 +0100rookie101(~rookie@165.232.121.13)
2021-12-09 08:26:02 +0100tv(~tv@user/tv)
2021-12-09 08:26:21 +0100 <int-e> xerox: here's a sample; it's just not very pretty at all: https://paste.debian.net/hidden/730b2e3c/
2021-12-09 08:26:34 +0100 <int-e> (yesterday, part 2)
2021-12-09 08:28:37 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 08:28:43 +0100 <int-e> it's mostly piecing together #haskell-style one-liners ;-)
2021-12-09 08:28:55 +0100xeroxnods - very nice!
2021-12-09 08:28:59 +0100 <xerox> appreciate it
2021-12-09 08:29:34 +0100 <xerox> that one I did on pen and paper, then hardcoded one decision tree, no search over permutations, I thought it'd be too much
2021-12-09 08:29:49 +0100 <int-e> > product [1..7]
2021-12-09 08:29:51 +0100 <lambdabot> 5040
2021-12-09 08:29:55 +0100 <int-e> not scary :)
2021-12-09 08:30:00 +0100 <xerox> definitely
2021-12-09 08:31:03 +0100root1(root@2600:3c02::f03c:92ff:fe1a:c779) (Ping timeout: 252 seconds)
2021-12-09 08:31:21 +0100 <xerox> I like your span, I often do remove the extra chars instead: https://github.com/mrtnpaolo/advent-of-code-2021/blob/master/execs/Day08.hs#L12-L15
2021-12-09 08:31:25 +0100root1(root@2600:3c02::f03c:92ff:fe1a:c779)
2021-12-09 08:31:36 +0100 <int-e> xerox: I actually did a post mortem where I tried a bit harder (narrowing it down to 8 out of 5040 cases): https://paste.debian.net/1222686/
2021-12-09 08:32:25 +0100 <xerox> ah see that's the kind of stuff I go dig into people's repositories to learn from
2021-12-09 08:32:53 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-12-09 08:32:56 +0100 <int-e> > let digits = words "abcefg cf acdeg acdfg bcdf abdfg abdefg acf abcdefg abcdfg" in M.fromListWith (+) [(c,length cs) | cs <- digits, c <- cs] -- fingerprinting segments
2021-12-09 08:32:57 +0100 <lambdabot> fromList [('a',43),('b',34),('c',38),('d',38),('e',24),('f',44),('g',40)]
2021-12-09 08:33:25 +0100 <int-e> (that one only made it to IRC)
2021-12-09 08:33:47 +0100 <int-e> huh, and it doesn't disambiguate c and d :-/
2021-12-09 08:34:44 +0100lagash(lagash@lagash.shelltalk.net) (Quit: ZNC - https://znc.in)
2021-12-09 08:35:13 +0100 <int-e> > let digits = words "abcefg cf acdeg acdfg bcdf abdfg abdefg acf abcdefg abcdfg" in M.fromListWith (+) [(c,1+length cs) | cs <- digits, c <- cs] -- fixed
2021-12-09 08:35:15 +0100 <lambdabot> fromList [('a',51),('b',40),('c',46),('d',45),('e',28),('f',53),('g',47)]
2021-12-09 08:36:09 +0100lagash(lagash@lagash.shelltalk.net)
2021-12-09 08:36:12 +0100 <int-e> the problem with clever stuff like this is that it usually takes tens of minutes to come up with ;)
2021-12-09 08:37:05 +0100 <xerox> it's an unbelievable cost these days (:
2021-12-09 08:38:35 +0100neurocyte0132889(~neurocyte@45.93.108.168)
2021-12-09 08:38:35 +0100neurocyte0132889(~neurocyte@45.93.108.168) (Changing host)
2021-12-09 08:38:35 +0100neurocyte0132889(~neurocyte@user/neurocyte)
2021-12-09 08:39:26 +0100_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-12-09 08:39:54 +0100 <int-e> xerox: oh yes I've used words . map quite a bit myself too
2021-12-09 08:42:25 +0100 <int-e> day 5... map (\c -> if c `elem` ",->" then ' ' else c)
2021-12-09 08:43:51 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 08:44:03 +0100mcgroin(~mcgroin@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr)
2021-12-09 08:44:15 +0100emf(~emf@2620:10d:c091:480::1:f5cb) (Ping timeout: 252 seconds)
2021-12-09 08:51:03 +0100 <xerox> exactly!
2021-12-09 08:51:14 +0100eggplantade(~Eggplanta@108-201-191-115.lightspeed.sntcca.sbcglobal.net) (Remote host closed the connection)
2021-12-09 08:51:15 +0100nfd(~nfd@user/nfd)
2021-12-09 08:52:51 +0100cfricke(~cfricke@user/cfricke)
2021-12-09 08:57:13 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-12-09 08:58:30 +0100df_df
2021-12-09 08:59:58 +0100mc47(~mc47@xmonad/TheMC47)
2021-12-09 09:02:23 +0100endor(~a@p200300ef97023511e49253ebeea0a61a.dip0.t-ipconnect.de)
2021-12-09 09:02:40 +0100zaquest(~notzaques@5.130.79.72) (Remote host closed the connection)
2021-12-09 09:03:49 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2021-12-09 09:04:24 +0100 <endor> Why is Data.HashTable.new returning an IO value? Why do we need side effects?
2021-12-09 09:05:26 +0100zaquest(~notzaques@5.130.79.72)
2021-12-09 09:06:05 +0100bollu(uid233390@id-233390.helmsley.irccloud.com)
2021-12-09 09:06:40 +0100dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-12-09 09:08:48 +0100 <int-e> where is Data.HashTable from?
2021-12-09 09:10:26 +0100 <endor> https://hackage.haskell.org/package/base-4.5.1.0/docs/Data-HashTable.html
2021-12-09 09:12:16 +0100Kevin578(~Kevin578@pool-96-237-112-198.bstnma.fios.verizon.net) (Remote host closed the connection)
2021-12-09 09:13:46 +0100vpan(~0@212.117.1.172)
2021-12-09 09:15:32 +0100 <int-e> oops, did I typo the import in ghci... I must have
2021-12-09 09:17:12 +0100 <int-e> Anyway, that is a mutable hashtable; each `new` must create its own array for storing the elements.
2021-12-09 09:17:42 +0100 <int-e> (This particular implementation creates an array even when there are no entries, which makes the code simpler.)
2021-12-09 09:17:49 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-12-09 09:19:04 +0100chele(~chele@user/chele)
2021-12-09 09:19:36 +0100max22-(~maxime@2a01cb088335980094e8e0f1650776df.ipv6.abo.wanadoo.fr)
2021-12-09 09:20:56 +0100 <endor> If the mutability is the reason for IO why does it not use ST internally?
2021-12-09 09:21:08 +0100 <int-e> Oh, no, I didn't make a typo. base-4.5.1 is ancient. Data.HashTable was removed in 4.7.0.0, 7 1/2 years ago.
2021-12-09 09:21:25 +0100 <endor> sorry!
2021-12-09 09:22:00 +0100 <int-e> There's https://hackage.haskell.org/package/hashtables which works in ST
2021-12-09 09:26:03 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 252 seconds)
2021-12-09 09:26:05 +0100 <endor> It says "the IO wrappers (which most users will probably prefer) ...".
2021-12-09 09:26:32 +0100 <endor> Why prefer IO wrapper? It makes things more complicated?
2021-12-09 09:27:48 +0100 <xerox> I guess it's more a comment about users than a comment about the functions
2021-12-09 09:28:55 +0100 <int-e> Maybe targeted at former users of Data.HashTable?
2021-12-09 09:29:53 +0100jgeerds(~jgeerds@55d4ac73.access.ecotel.net)
2021-12-09 09:30:37 +0100 <dminuoso> It seems this library could have been written polymorphically over PrimMonad as well
2021-12-09 09:31:04 +0100 <dminuoso> Then you would have had just singular versions
2021-12-09 09:31:49 +0100mcgroin(~mcgroin@roc37-h01-176-170-197-243.dsl.sta.abo.bbox.fr) (Ping timeout: 240 seconds)
2021-12-09 09:32:07 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 09:34:25 +0100_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-12-09 09:35:02 +0100jgeerds(~jgeerds@55d4ac73.access.ecotel.net) (Ping timeout: 252 seconds)
2021-12-09 09:36:57 +0100w1gz(~do@159.89.11.133)
2021-12-09 09:43:01 +0100max22-(~maxime@2a01cb088335980094e8e0f1650776df.ipv6.abo.wanadoo.fr) (Ping timeout: 240 seconds)
2021-12-09 09:43:03 +0100notzmv(~zmv@user/notzmv)
2021-12-09 09:43:55 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 265 seconds)
2021-12-09 09:45:27 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 09:46:15 +0100AndrejKarpathy(~AndrejKar@2409:4053:2e02:82b0:42d:753e:851e:5c65)
2021-12-09 09:46:49 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-12-09 09:46:59 +0100AndrejKarpathy(~AndrejKar@2409:4053:2e02:82b0:42d:753e:851e:5c65) (Client Quit)
2021-12-09 09:47:01 +0100 <int-e> dminuoso: Even if I'd target PrimMonad I'd start by implementing everything for ST s first; I don't see how a polymorphic use of `primitive` could ever play well with ghc's optimizer
2021-12-09 09:47:32 +0100Angel89(~Angel89@2409:4053:2e02:82b0:42d:753e:851e:5c65)
2021-12-09 09:48:33 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-12-09 09:51:37 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f80d:43f5:ddf4:fb26)
2021-12-09 09:54:57 +0100Angel89(~Angel89@2409:4053:2e02:82b0:42d:753e:851e:5c65) (Quit: Client closed)
2021-12-09 09:55:35 +0100Angel89(~Angel89@2409:4053:2e02:82b0:42d:753e:851e:5c65)
2021-12-09 09:56:30 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f80d:43f5:ddf4:fb26) (Ping timeout: 268 seconds)
2021-12-09 09:56:44 +0100Akiva(~Akiva@user/Akiva)
2021-12-09 09:58:24 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-12-09 10:00:06 +0100OndejSkup[m](~mimivxmat@2001:470:69fc:105::c300) (Quit: You have been kicked for being idle)
2021-12-09 10:00:09 +0100Tavi[m](~factoidde@2001:470:69fc:105::1:819) (Quit: You have been kicked for being idle)
2021-12-09 10:00:10 +0100kosmikus[m](~andresloe@2001:470:69fc:105::95d) (Quit: You have been kicked for being idle)
2021-12-09 10:02:01 +0100ubert(~Thunderbi@p200300ecdf0ba2f664fe176011d10d59.dip0.t-ipconnect.de)
2021-12-09 10:05:28 +0100bitmapper(uid464869@id-464869.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2021-12-09 10:09:10 +0100k60``(~user@static.100.218.46.78.clients.your-server.de) (Ping timeout: 256 seconds)
2021-12-09 10:10:21 +0100synthmeat(~synthmeat@user/synthmeat) (Quit: WeeChat 3.0)
2021-12-09 10:12:34 +0100acidjnk_new(~acidjnk@p200300d0c7271e730cb547fb259b1246.dip0.t-ipconnect.de)
2021-12-09 10:14:33 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net)
2021-12-09 10:14:36 +0100pfurla(~pfurla@2804:14d:5c81:4104:e550:12e4:9dfb:af3c)
2021-12-09 10:14:54 +0100xkuru(~xkuru@user/xkuru)
2021-12-09 10:15:49 +0100nunggu(~q@gateway/tor-sasl/nunggu)
2021-12-09 10:16:00 +0100m1dnight(~christoph@christophe.dev)
2021-12-09 10:17:35 +0100geekosaur(~geekosaur@xmonad/geekosaur) (Killed (NickServ (GHOST command used by allbery_b)))
2021-12-09 10:17:35 +0100allbery_b(~geekosaur@xmonad/geekosaur)
2021-12-09 10:17:38 +0100allbery_bgeekosaur
2021-12-09 10:18:37 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net) (Ping timeout: 240 seconds)
2021-12-09 10:20:17 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 10:20:39 +0100Akiva(~Akiva@user/Akiva) (Ping timeout: 265 seconds)
2021-12-09 10:21:37 +0100xff0x(~xff0x@2001:1a81:5338:9c00:2366:f1e5:f2a7:3295) (Ping timeout: 265 seconds)
2021-12-09 10:22:22 +0100xff0x(~xff0x@2001:1a81:5338:9c00:c1d:978d:6bc0:7433)
2021-12-09 10:22:38 +0100tcard(~tcard@p2878075-ipngn18701hodogaya.kanagawa.ocn.ne.jp) (Quit: Leaving)
2021-12-09 10:22:52 +0100Dansk31(~Dansk31@213.244.23.3)
2021-12-09 10:23:51 +0100Dansk31(~Dansk31@213.244.23.3) (Client Quit)
2021-12-09 10:25:59 +0100Angel89(~Angel89@2409:4053:2e02:82b0:42d:753e:851e:5c65) (Quit: Client closed)
2021-12-09 10:27:07 +0100tcard(~tcard@p2878075-ipngn18701hodogaya.kanagawa.ocn.ne.jp)
2021-12-09 10:32:24 +0100Alex_test(~al_test@94.233.241.193)
2021-12-09 10:32:42 +0100 <Profpatsch> GHC can’t derive Show1?
2021-12-09 10:32:49 +0100 <Profpatsch> That’s a bummer
2021-12-09 10:33:58 +0100mjacob(~mjacob@adrastea.uberspace.de) (Read error: Connection reset by peer)
2021-12-09 10:34:06 +0100Alex_test_(~al_test@94.233.241.193) (Ping timeout: 256 seconds)
2021-12-09 10:34:25 +0100 <Profpatsch> Ah, maybe GHC 9
2021-12-09 10:34:40 +0100vpan(~0@212.117.1.172) (Ping timeout: 256 seconds)
2021-12-09 10:35:14 +0100m1dnight(~christoph@christophe.dev) (Ping timeout: 256 seconds)
2021-12-09 10:35:21 +0100vpan(~0@212.117.1.172)
2021-12-09 10:35:24 +0100Arsen(arsen@managarm/dev/Arsen) (Quit: Quit.)
2021-12-09 10:35:44 +0100Angel89(~Angel89@2409:4053:2e02:82b0:42d:753e:851e:5c65)
2021-12-09 10:38:41 +0100m1dnight(~christoph@christophe.dev)
2021-12-09 10:41:26 +0100Angel89(~Angel89@2409:4053:2e02:82b0:42d:753e:851e:5c65) (Quit: Client closed)
2021-12-09 10:42:20 +0100Arsen(arsen@managarm/dev/Arsen)
2021-12-09 10:46:12 +0100ChaiTRex(~ChaiTRex@user/chaitrex) (Remote host closed the connection)
2021-12-09 10:46:41 +0100ChaiTRex(~ChaiTRex@user/chaitrex)
2021-12-09 10:49:30 +0100teo(~teo@user/teo)
2021-12-09 10:49:55 +0100mjacob(~mjacob@adrastea.uberspace.de)
2021-12-09 10:52:40 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-12-09 10:53:16 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-12-09 10:54:29 +0100Erutuon(~Erutuon@user/erutuon) (Ping timeout: 265 seconds)
2021-12-09 10:58:50 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net) (Ping timeout: 265 seconds)
2021-12-09 10:59:19 +0100k60``(~user@static.100.218.46.78.clients.your-server.de)
2021-12-09 11:00:13 +0100werneta(~werneta@70-142-214-115.lightspeed.irvnca.sbcglobal.net)
2021-12-09 11:03:34 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 256 seconds)
2021-12-09 11:06:48 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net) (Quit: zzz)
2021-12-09 11:06:53 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Ping timeout: 252 seconds)
2021-12-09 11:07:12 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-12-09 11:07:23 +0100Merfont(~Kaiepi@156.34.44.192) (Remote host closed the connection)
2021-12-09 11:10:37 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 240 seconds)
2021-12-09 11:11:34 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2021-12-09 11:15:32 +0100feetwind(~mike@user/feetwind) (Ping timeout: 240 seconds)
2021-12-09 11:17:03 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 11:17:31 +0100gehmehgeh(~user@user/gehmehgeh)
2021-12-09 11:17:50 +0100dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Quit: WeeChat 3.3)
2021-12-09 11:18:08 +0100 <merijn> hmmm
2021-12-09 11:18:11 +0100 <merijn> rats
2021-12-09 11:18:39 +0100 <merijn> my AoC solution works fine for the small example, but fails on the big one :\
2021-12-09 11:18:52 +0100nebu(~user@user/wavion) (Ping timeout: 256 seconds)
2021-12-09 11:19:03 +0100 <dminuoso> Mmm, why does executableStripping does less than manually invoking `strip`?
2021-12-09 11:19:21 +0100 <dminuoso> *executable-stripping in cabal
2021-12-09 11:20:09 +0100 <dminuoso> With `split-sections: true` and `executable-stripping: true` it brings down the resulting static binary to 74MiB, but calling strip ontop gets it down to 40ish
2021-12-09 11:20:48 +0100teo(~teo@user/teo) (Read error: Connection reset by peer)
2021-12-09 11:21:42 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 256 seconds)
2021-12-09 11:22:01 +0100 <merijn> ah, < vs <= strikes again :p
2021-12-09 11:25:25 +0100synthmeat(~synthmeat@user/synthmeat)
2021-12-09 11:27:47 +0100user0(~aj@langw.roketelkom.co.ug) (Quit: Leaving.)
2021-12-09 11:27:54 +0100feetwind(~mike@user/feetwind)
2021-12-09 11:29:10 +0100user0(~aj@langw.roketelkom.co.ug)
2021-12-09 11:30:51 +0100nebu(~user@user/wavion)
2021-12-09 11:31:57 +0100aveltras(~aveltras@2a01:cb1e:4c:f668:5c2f:6f8c:9239:752b)
2021-12-09 11:32:56 +0100obfusk(~quassel@a82-161-150-56.adsl.xs4all.nl) (Remote host closed the connection)
2021-12-09 11:34:08 +0100obfusk(~quassel@a82-161-150-56.adsl.xs4all.nl)
2021-12-09 11:36:03 +0100nebu(~user@user/wavion) (Ping timeout: 265 seconds)
2021-12-09 11:36:13 +0100Techcable(~Techcable@168.235.93.147) (Ping timeout: 252 seconds)
2021-12-09 11:36:39 +0100nebu(~user@user/wavion)
2021-12-09 11:37:39 +0100mncheck(~mncheck@193.224.205.254) (Read error: Connection reset by peer)
2021-12-09 11:38:43 +0100jinsun__(~quassel@user/jinsun)
2021-12-09 11:39:04 +0100 <aveltras> is anyone aware of some limitations regarding using ghc plugins and at the same time libraries using ffi ? i've setup a minimal repo demonstrating the issue encountered https://github.com/aveltras/pulsar-hs-repro
2021-12-09 11:39:25 +0100jinsun(~quassel@user/jinsun) (Ping timeout: 240 seconds)
2021-12-09 11:40:44 +0100aveltras[m](~aveltrasm@2001:470:69fc:105::3ef9)
2021-12-09 11:41:03 +0100raehik(~raehik@cpc95906-rdng25-2-0-cust156.15-3.cable.virginm.net)
2021-12-09 11:41:17 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2021-12-09 11:41:25 +0100nebu(~user@user/wavion) (Ping timeout: 240 seconds)
2021-12-09 11:49:00 +0100jakalx(~jakalx@base.jakalx.net)
2021-12-09 11:51:31 +0100fr33domlover(~fr33@2.55.41.129)
2021-12-09 11:51:43 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 11:53:25 +0100nebu(~user@user/wavion)
2021-12-09 11:56:41 +0100feliix42(~felix@gibbs.uberspace.de) (Read error: Connection reset by peer)
2021-12-09 11:59:15 +0100nebu(~user@user/wavion) (Ping timeout: 265 seconds)
2021-12-09 11:59:52 +0100feliix42(~felix@gibbs.uberspace.de)
2021-12-09 12:00:19 +0100namkeleser(~namkelese@101.175.128.51)
2021-12-09 12:00:40 +0100alx741(~alx741@186.178.108.192)
2021-12-09 12:02:00 +0100Cajun(~Cajun@user/cajun) (Quit: Client closed)
2021-12-09 12:08:21 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2021-12-09 12:13:55 +0100user01(~aj@154.0.137.32)
2021-12-09 12:17:03 +0100jippiedoe(~david@2a02-a44c-e14e-1-4578-432f-df10-dcae.fixed6.kpn.net)
2021-12-09 12:17:14 +0100user0(~aj@langw.roketelkom.co.ug) (Ping timeout: 256 seconds)
2021-12-09 12:18:58 +0100shriekingnoise(~shrieking@186.137.144.80)
2021-12-09 12:25:06 +0100teo(~teo@user/teo)
2021-12-09 12:26:47 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2021-12-09 12:28:15 +0100smartin(~Thunderbi@88.135.18.171)
2021-12-09 12:30:45 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 12:33:47 +0100 <xerox> anybody knows how to attack this? https://i.imgur.com/NsAh0lK.png
2021-12-09 12:34:53 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-12-09 12:35:01 +0100k60``(~user@static.100.218.46.78.clients.your-server.de) (Ping timeout: 265 seconds)
2021-12-09 12:35:22 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 256 seconds)
2021-12-09 12:35:32 +0100Francimansuggests switching to ocaml
2021-12-09 12:36:26 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 12:36:37 +0100xkuru(~xkuru@user/xkuru) (Remote host closed the connection)
2021-12-09 12:36:38 +0100 <geekosaur> are you using head.hackage?
2021-12-09 12:36:47 +0100 <xerox> no
2021-12-09 12:36:59 +0100xkuru(~xkuru@user/xkuru)
2021-12-09 12:38:33 +0100 <geekosaur> you probably need it given the shown compiler version
2021-12-09 12:38:47 +0100 <xerox> interesting, I guess I can try
2021-12-09 12:39:35 +0100 <geekosaur> the point of head.hackage is it's patches to various packages needed toi get them to build with newer ghcs (originally intended with ghc HEAD but also helpful with 9.2.1)
2021-12-09 12:40:29 +0100 <geekosaur> levity/representation polymorphism is still new enough that a number of packages don't know how to deal with it yet
2021-12-09 12:40:49 +0100 <xerox> hm nope, the head.h.o version does not compile either
2021-12-09 12:41:47 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-12-09 12:41:51 +0100whatsupdoc(uid509081@id-509081.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-12-09 12:42:24 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 12:43:26 +0100mbuf(~Shakthi@122.178.122.215) (Quit: Leaving)
2021-12-09 12:44:28 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca) (Remote host closed the connection)
2021-12-09 12:45:38 +0100machinedgod(~machinedg@135-23-192-217.cpe.pppoe.ca)
2021-12-09 12:46:52 +0100k60``(~user@static.100.218.46.78.clients.your-server.de)
2021-12-09 12:47:50 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-12-09 12:48:14 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 12:48:27 +0100max22-(~maxime@2a01cb08833598006ab9bb661d4b4059.ipv6.abo.wanadoo.fr)
2021-12-09 12:48:45 +0100mei(~mei@user/mei)
2021-12-09 12:49:55 +0100jippiedoe(~david@2a02-a44c-e14e-1-4578-432f-df10-dcae.fixed6.kpn.net) (Ping timeout: 252 seconds)
2021-12-09 12:53:25 +0100cods(~fred@82-65-232-44.subs.proxad.net) (Ping timeout: 256 seconds)
2021-12-09 12:53:30 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-12-09 12:54:06 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 12:54:17 +0100mncheck(~mncheck@193.224.205.254)
2021-12-09 12:54:44 +0100endor(~a@p200300ef97023511e49253ebeea0a61a.dip0.t-ipconnect.de) (Quit: WeeChat 3.0.1)
2021-12-09 12:56:16 +0100 <geekosaur> next step is probably to ask in #ghc then
2021-12-09 12:56:59 +0100 <geekosaur> you're not going to get much help with ghc 9.3.x in here
2021-12-09 12:57:18 +0100pfurla(~pfurla@2804:14d:5c81:4104:e550:12e4:9dfb:af3c) (Quit: gone to sleep. ZZZzzz…)
2021-12-09 12:59:39 +0100noctux(~noctux@user/noctux) (Ping timeout: 268 seconds)
2021-12-09 13:00:05 +0100pfurla(~pfurla@201.17.118.230)
2021-12-09 13:01:08 +0100__monty__(~toonn@user/toonn)
2021-12-09 13:03:01 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 240 seconds)
2021-12-09 13:04:12 +0100Cajun(~Cajun@user/cajun)
2021-12-09 13:04:30 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-12-09 13:04:33 +0100 <xerox> - tagToEnum# (unsafeCoerce# reallyUnsafePtrEquality# xs ys)
2021-12-09 13:04:33 +0100 <xerox> + tagToEnum# (unsafeCoerce# (reallyUnsafePtrEquality# xs ys))
2021-12-09 13:04:35 +0100 <xerox> this does the trick
2021-12-09 13:04:41 +0100 <xerox> 🤷‍♂️
2021-12-09 13:05:22 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 13:05:35 +0100 <Franciman> *shrugs*
2021-12-09 13:06:33 +0100 <geekosaur> that does look saner to me. wonder why the original code
2021-12-09 13:06:42 +0100 <xerox> I'll ask
2021-12-09 13:07:46 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 13:09:02 +0100Kaiepi(~Kaiepi@156.34.44.192)
2021-12-09 13:10:30 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-12-09 13:11:08 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 13:12:26 +0100AlexNoo_AlexNoo
2021-12-09 13:13:18 +0100noctux(~noctux@user/noctux)
2021-12-09 13:15:03 +0100bliminse(~bliminse@host86-162-147-196.range86-162.btcentralplus.com) (Quit: leaving)
2021-12-09 13:15:35 +0100cods(~fred@82-65-232-44.subs.proxad.net)
2021-12-09 13:16:13 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-12-09 13:16:42 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 13:19:32 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2021-12-09 13:21:50 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-12-09 13:22:52 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 13:23:17 +0100jakalx(~jakalx@base.jakalx.net)
2021-12-09 13:26:53 +0100k60``(~user@static.100.218.46.78.clients.your-server.de) (Remote host closed the connection)
2021-12-09 13:28:11 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-12-09 13:28:56 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 13:29:19 +0100synthmeat(~synthmeat@user/synthmeat) (Quit: WeeChat 3.0)
2021-12-09 13:30:46 +0100k60``(~user@static.100.218.46.78.clients.your-server.de)
2021-12-09 13:31:55 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-12-09 13:33:36 +0100burnsidesLlama(~burnsides@dhcp168-015.wadham.ox.ac.uk)
2021-12-09 13:34:28 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-12-09 13:34:53 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 13:38:27 +0100Techcable(~Techcable@168.235.93.147)
2021-12-09 13:38:45 +0100aveltras(~aveltras@2a01:cb1e:4c:f668:5c2f:6f8c:9239:752b) (Ping timeout: 256 seconds)
2021-12-09 13:43:47 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Remote host closed the connection)
2021-12-09 13:43:50 +0100bliminse(~bliminse@host86-162-147-196.range86-162.btcentralplus.com)
2021-12-09 13:44:05 +0100azimut(~azimut@gateway/tor-sasl/azimut)
2021-12-09 13:47:29 +0100genieliu(~genieliu@103.37.140.24)
2021-12-09 13:47:59 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-12-09 13:51:22 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net)
2021-12-09 13:52:22 +0100Kaiepi(~Kaiepi@156.34.44.192) (Remote host closed the connection)
2021-12-09 13:52:42 +0100Kaiepi(~Kaiepi@156.34.44.192)
2021-12-09 13:55:18 +0100nebu(~user@user/wavion)
2021-12-09 13:55:50 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net) (Ping timeout: 256 seconds)
2021-12-09 13:56:13 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f80d:43f5:ddf4:fb26)
2021-12-09 14:00:41 +0100max22-(~maxime@2a01cb08833598006ab9bb661d4b4059.ipv6.abo.wanadoo.fr) (Ping timeout: 252 seconds)
2021-12-09 14:00:42 +0100nebu(~user@user/wavion) (Ping timeout: 268 seconds)
2021-12-09 14:01:19 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f80d:43f5:ddf4:fb26) (Ping timeout: 268 seconds)
2021-12-09 14:02:04 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 256 seconds)
2021-12-09 14:02:37 +0100mrckndt(~mrckndt@user/mrckndt) (Quit: mrckndt)
2021-12-09 14:03:49 +0100cfricke(~cfricke@user/cfricke) (Ping timeout: 240 seconds)
2021-12-09 14:04:12 +0100euandreh(~euandreh@2804:14c:33:9fe5:cd28:ecf9:b8a2:d95a)
2021-12-09 14:09:38 +0100burnsidesLlama(~burnsides@dhcp168-015.wadham.ox.ac.uk) (Remote host closed the connection)
2021-12-09 14:10:40 +0100namkeleser(~namkelese@101.175.128.51) (Quit: Client closed)
2021-12-09 14:11:46 +0100jakalx(~jakalx@base.jakalx.net) (Disconnected: Replaced by new connection)
2021-12-09 14:11:46 +0100jakalx(~jakalx@base.jakalx.net)
2021-12-09 14:12:24 +0100bitmapper(uid464869@id-464869.lymington.irccloud.com)
2021-12-09 14:13:00 +0100 <merijn> Suppose I have a function 'A -> A', an 'A', and a predicate 'A -> Bool', what's the most convenient way to get "the first value satisfying the predicate"?
2021-12-09 14:13:21 +0100jippiedoe(~david@2a02-a44c-e14e-1-1201-1886-c45a-80e6.fixed6.kpn.net)
2021-12-09 14:15:15 +0100 <geekosaur> I feel like there's a ppiece missing here
2021-12-09 14:15:39 +0100 <merijn> How so?
2021-12-09 14:16:02 +0100 <geekosaur> you have "an A", where do you have multiple values to get the first of?
2021-12-09 14:16:08 +0100 <maerwald> head . filter p . iterate f
2021-12-09 14:16:10 +0100 <maerwald> ?
2021-12-09 14:16:14 +0100 <merijn> geekosaur: Applying the function to the initial value
2021-12-09 14:16:22 +0100 <geekosaur> ah
2021-12-09 14:16:35 +0100 <geekosaur> maerwald probably has it
2021-12-09 14:16:38 +0100 <merijn> maerwald: Yeah, I was thinking along those lines, but wasn't really happy with that :\
2021-12-09 14:16:41 +0100 <merijn> oh well
2021-12-09 14:16:45 +0100 <maerwald> well, safeHead
2021-12-09 14:16:56 +0100 <merijn> Damn control characters in unicode fucking up my use of succ :\
2021-12-09 14:17:30 +0100 <geekosaur> unicode succs?
2021-12-09 14:17:53 +0100 <merijn> oh, wait, an idea appears!
2021-12-09 14:18:43 +0100 <merijn> I'd almost forgot Haskell is lazy there...
2021-12-09 14:19:16 +0100 <merijn> Problem avoided instead :p
2021-12-09 14:20:39 +0100 <merijn> I can just generate an infinite list of printable character and take the head at every step, instead of computing the next one
2021-12-09 14:23:20 +0100CiaoSen(~Jura@p200300c9570204002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2021-12-09 14:23:46 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2021-12-09 14:29:19 +0100kaction(~kaction@pool-71-191-91-40.washdc.fios.verizon.net)
2021-12-09 14:35:51 +0100genieliu(~genieliu@103.37.140.24) (Ping timeout: 265 seconds)
2021-12-09 14:36:34 +0100Morrow(~quassel@bzq-110-168-31-106.red.bezeqint.net) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2021-12-09 14:40:44 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 14:41:09 +0100burnsidesLlama(~burnsides@dhcp168-015.wadham.ox.ac.uk)
2021-12-09 14:41:22 +0100Morrow(~quassel@bzq-110-168-31-106.red.bezeqint.net)
2021-12-09 14:42:08 +0100jippiedoe(~david@2a02-a44c-e14e-1-1201-1886-c45a-80e6.fixed6.kpn.net) (Ping timeout: 265 seconds)
2021-12-09 14:42:47 +0100TheCoffeMaker(~TheCoffeM@user/thecoffemaker) (Ping timeout: 256 seconds)
2021-12-09 14:43:12 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Quit: ERC (IRC client for Emacs 26.3))
2021-12-09 14:44:00 +0100vpan(~0@212.117.1.172) (Quit: Leaving.)
2021-12-09 14:45:26 +0100TheCoffeMaker(~TheCoffeM@user/thecoffemaker)
2021-12-09 14:46:43 +0100pfurla(~pfurla@201.17.118.230) (Quit: gone to sleep. ZZZzzz…)
2021-12-09 14:46:58 +0100burnsidesLlama(~burnsides@dhcp168-015.wadham.ox.ac.uk) (Ping timeout: 265 seconds)
2021-12-09 14:48:21 +0100azimut_(~azimut@gateway/tor-sasl/azimut)
2021-12-09 14:49:25 +0100burnsidesLlama(~burnsides@dhcp168-015.wadham.ox.ac.uk)
2021-12-09 14:49:46 +0100 <merijn> hmm, I feel like I'm missing some tricks for writing convenient fixpoints
2021-12-09 14:51:54 +0100azimut(~azimut@gateway/tor-sasl/azimut) (Ping timeout: 276 seconds)
2021-12-09 14:52:46 +0100xsperry(~xs@user/xsperry) (Ping timeout: 265 seconds)
2021-12-09 14:53:49 +0100burnsidesLlama(~burnsides@dhcp168-015.wadham.ox.ac.uk) (Ping timeout: 240 seconds)
2021-12-09 14:57:23 +0100kupi(uid212005@id-212005.hampstead.irccloud.com)
2021-12-09 14:59:52 +0100 <xerox> how does one get access to the cabal project version in an app's Main.hs ?
2021-12-09 14:59:59 +0100xsperry(~xs@user/xsperry)
2021-12-09 15:00:01 +0100 <xerox> could it be the cabal Paths.hs thing
2021-12-09 15:00:12 +0100 <merijn> xerox: You mean the version from the cabal file?
2021-12-09 15:00:34 +0100 <merijn> like 0.1.0.0 or whatever
2021-12-09 15:01:08 +0100max22-(~maxime@2a01cb0883359800d97fa420b95dd877.ipv6.abo.wanadoo.fr)
2021-12-09 15:02:47 +0100fr33domlover(~fr33@2.55.41.129) (Quit: fr33domlover)
2021-12-09 15:09:21 +0100 <boxscape> kind of wish iterate et al. would produce `data Stream a = a :|| Stream a`, and then you could use `head` without worrying about empty lists
2021-12-09 15:09:53 +0100chexum(~quassel@gateway/tor-sasl/chexum) (Remote host closed the connection)
2021-12-09 15:10:36 +0100jippiedoe(~david@2a02-a44c-e14e-1-9f6f-678f-3cd5-9f8c.fixed6.kpn.net)
2021-12-09 15:10:54 +0100 <merijn> You can still use head without worrying about empty lists...
2021-12-09 15:11:00 +0100 <merijn> That seems like a silly statement
2021-12-09 15:11:20 +0100chexum(~quassel@gateway/tor-sasl/chexum)
2021-12-09 15:11:22 +0100 <dminuoso> Btw, if you have both a cabal.project and cabal.project.local, and both specify `packages: .`, then `cabal build` will find the package in your current directory twice and complain
2021-12-09 15:11:25 +0100 <dminuoso> Is this by design?
2021-12-09 15:11:37 +0100 <boxscape> Yes, but then I have this nagging thought at the back of my mind that I'll eventually accidentally refactor the code to something that makes the `head` call unsafe, and I'm not protected by the type system
2021-12-09 15:12:16 +0100 <merijn> dminuoso: The cabal.project.local fields (depending on type) overwrite OR monoidally append the ones from cabal.project
2021-12-09 15:12:19 +0100 <merijn> dminuoso: So...yes
2021-12-09 15:12:28 +0100 <boxscape> (presumably something similar is why maerwald suggested safeHead above)
2021-12-09 15:12:34 +0100 <merijn> dminuoso: Why are you even listing packages in cabal.project.local?
2021-12-09 15:13:13 +0100 <dminuoso> merijn: Just a copy/paste result.
2021-12-09 15:13:25 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net)
2021-12-09 15:13:39 +0100 <merijn> My main complaint about Haskell for AOC is that I need to waste to many lines on imports >.>
2021-12-09 15:13:44 +0100 <dminuoso> I figured if I wanted to customize the cabal.project on my local machine, Id just copy the file and tweak it. Somehow I assumed that this would take predence
2021-12-09 15:14:07 +0100 <merijn> dminuoso: No, you just take an empty file and only write whatever you wanna change in cabal.project.local
2021-12-09 15:14:27 +0100 <dminuoso> Where can I find whether fields are overwritten or appended?
2021-12-09 15:14:36 +0100 <dminuoso> Let me guess. source code?
2021-12-09 15:14:38 +0100 <merijn> dminuoso: list-y fields should be appended
2021-12-09 15:14:51 +0100 <merijn> dminuoso: Same logic as in .cabal files
2021-12-09 15:15:00 +0100 <merijn> Since they use the same field parsers
2021-12-09 15:15:42 +0100 <merijn> dminuoso: Not having to duplicate the entire original project file is the entire point of having .local files builtin :p
2021-12-09 15:16:52 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 256 seconds)
2021-12-09 15:16:54 +0100 <dminuoso> Fair enough, thanks
2021-12-09 15:17:29 +0100dmenz(~dmenz@2804:14d:5cd4:5e94::1)
2021-12-09 15:17:30 +0100stevenxl(~stevenxl@174.128.182.199)
2021-12-09 15:21:47 +0100genieliu(~genieliu@111.193.167.10)
2021-12-09 15:22:54 +0100burnsidesLlama(~burnsides@dhcp168-015.wadham.ox.ac.uk)
2021-12-09 15:23:42 +0100CiaoSen(~Jura@p200300c9570204002a3a4dfffe84dbd5.dip0.t-ipconnect.de) (Ping timeout: 265 seconds)
2021-12-09 15:24:40 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-12-09 15:24:40 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-12-09 15:24:40 +0100wroathe(~wroathe@user/wroathe)
2021-12-09 15:25:46 +0100 <fizbin> Last night, sm mentioned a "stack script". This is not something I had ever heard of before - did they mean using something like https://www.fpcomplete.com/haskell/tutorial/stack-script/ ?
2021-12-09 15:27:03 +0100 <byorgey> fizbin: probably, that's the only thing called a "stack script" that I know of.
2021-12-09 15:27:34 +0100burnsidesLlama(~burnsides@dhcp168-015.wadham.ox.ac.uk) (Ping timeout: 265 seconds)
2021-12-09 15:27:34 +0100genieliu(~genieliu@111.193.167.10) (Ping timeout: 265 seconds)
2021-12-09 15:28:58 +0100 <fizbin> It definitely does simplify the setup, though having the stack.yaml and package.yaml files there are still convenient because with all three of stack.yaml, package.yaml and hie.yaml working together I now have the haskell language server functioning on this code.
2021-12-09 15:29:32 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 15:30:17 +0100 <fizbin> merijn: I haven't found the need for too many import lines. Plus, you can always have those import lines prefilled and ready to go before the problem drops.
2021-12-09 15:30:35 +0100 <fizbin> (Of course, I should talk, since I get my timed solutions done via python)
2021-12-09 15:36:46 +0100Successus(~Successus@gateway/tor-sasl/successus)
2021-12-09 15:37:56 +0100 <merijn> fizbin: It depends how you write your code. I could probably get dirty solutions without to many imports
2021-12-09 15:38:33 +0100dmenz(~dmenz@2804:14d:5cd4:5e94::1) (Quit: Leaving)
2021-12-09 15:38:34 +0100 <merijn> fizbin: Personal rule: No unhandled errors and nice abstractions for that sorta thing tend to rack up the imports :p
2021-12-09 15:38:54 +0100 <merijn> Today's solution has, like, 25 lines of import >.>
2021-12-09 15:39:34 +0100 <merijn> I could probably optimise it a bit by moving frequent code into a separate library modules and reusing that. But I kinda like each day being standalone. Makes them function better as examples for others
2021-12-09 15:39:35 +0100synthmeat(~synthmeat@user/synthmeat)
2021-12-09 15:40:06 +0100ub(~Thunderbi@p200300ecdf0ba2f69d45b59a7f50dcfc.dip0.t-ipconnect.de)
2021-12-09 15:43:06 +0100 <byorgey> yeah, I make each day standalone too
2021-12-09 15:43:15 +0100 <fizbin> Combined across my solutions to the first 9 problems, I have 9 distinct 'import' lines: Control.Monad, Data.Char, Data.List, Data.Maybe, Debug.Trace, Numeric, System.Environment, qualified Data.Map as M, and qualified Data.MultiSet as MS.
2021-12-09 15:43:38 +0100pfurla(~pfurla@2804:14d:5c81:4104:25b5:2708:65a9:4e7d)
2021-12-09 15:43:38 +0100 <fizbin> It's not so bad to have a template with {-# LANGUAGE Haskell2010 #-} and those 9 lines.
2021-12-09 15:44:57 +0100 <merijn> fizbin: Control.Monad, Data.Char, Data.Coerce, Data.Foldable, Data.Function, Data.Funtor.Identity, Data.List, Data.List.NonEmpty, 2x Data.Map (qualified and type), Data.Maybe, Data.Monoid, Data.Ord, Data.Semigroup, Data.Text, Data.Text.IO, Data.Void, System.Environment, System.Exist, System.IO and 3 Megaparsec ones :p
2021-12-09 15:45:23 +0100 <fizbin> Already this year, or is that your template?
2021-12-09 15:45:30 +0100 <merijn> That's just day9 :p
2021-12-09 15:45:57 +0100 <byorgey> my template for solving problems on open.kattis.com has ... 46 lines of imports =)
2021-12-09 15:46:35 +0100 <fizbin> As an aside, I've found this year's input parsing to be much simpler than in earlier years. By this point in 2020, we'd already needed to parse input like "light red bags contain 1 bright white bag, 2 muted yellow bags."
2021-12-09 15:46:52 +0100 <fizbin> So far this year, I've done all the parsing with "lines" and "words".
2021-12-09 15:46:55 +0100 <byorgey> fizbin: agreed.
2021-12-09 15:47:46 +0100 <merijn> fizbin: You can do it with lines/words if you assume only valid input, which violates my attempt to handle all errors explicitly approach :p
2021-12-09 15:48:22 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2021-12-09 15:48:28 +0100 <merijn> Not sure if I actually handle *everything*, but certainly the vast majority of cases
2021-12-09 15:49:05 +0100 <byorgey> heh. My day 9 solution only has 6 imports: Control.Arrow, Data.Array.Unboxed, Data.List, Data.Maybe, and 2x Data.Set
2021-12-09 15:49:59 +0100 <fizbin> TBH if I were doing that, (input validation) I'd do it with regex.
2021-12-09 15:50:11 +0100 <byorgey> merijn: throw up your solution on a web server and let us try to send it malicious inputs =)
2021-12-09 15:50:29 +0100smartin(~Thunderbi@88.135.18.171) (Remote host closed the connection)
2021-12-09 15:51:04 +0100jinsun__jinsun
2021-12-09 15:51:49 +0100 <merijn> byorgey: You can clone the repo and throw malicious input at it yourself :p
2021-12-09 15:52:00 +0100curiousgay(~curiousga@77-120-141-90.kha.volia.net) (Quit: Leaving)
2021-12-09 15:52:12 +0100 <fizbin> byorgey: If I remove the Debug.Trace import (that isn't needed in the final version but was very much needed during development), I only have 5 on day 9: Data.List, Data.Maybe, System.Environment, qualified Data.Map as M, qualified Data.MultiSet as MS
2021-12-09 15:52:13 +0100motherfsck(~motherfsc@user/motherfsck)
2021-12-09 15:52:21 +0100 <merijn> byorgey: I just want with a Map for the data structure :p
2021-12-09 15:52:51 +0100Kevin578(~Kevin578@pool-96-237-112-198.bstnma.fios.verizon.net)
2021-12-09 15:52:56 +0100 <byorgey> merijn: hehe
2021-12-09 15:52:58 +0100 <byorgey> fizbin: nice
2021-12-09 15:53:00 +0100 <merijn> byorgey: https://github.com/merijn/AdventOfCode/blob/master/Day9.hs
2021-12-09 15:53:15 +0100 <merijn> I did also include a renderer for my maps for debugging purposes
2021-12-09 15:54:38 +0100 <byorgey> merijn: ah, I like your way of finding basins using repeated convolution
2021-12-09 15:54:51 +0100 <byorgey> I just used BFS
2021-12-09 15:55:01 +0100 <fizbin> I'm not sure how people get by without having their "main" get the name of the input file with getArgs, though I guess people could be writing stuff to always read the input from stdin. (Personally, I write my solutions - python and haskell - to take an optional first argument that's the input file with the default being "aocNN.in")
2021-12-09 15:55:07 +0100 <merijn> byorgey: Yeah, I'm quite pleased with that and (in general) the generic convolution
2021-12-09 15:55:30 +0100Tuplanolla(~Tuplanoll@91-159-69-50.elisa-laajakaista.fi)
2021-12-09 15:55:40 +0100 <merijn> byorgey: Given some of the earlier puzzles I expect more convolutions to come :p
2021-12-09 15:55:51 +0100 <merijn> byorgey: So I figured I can easily copy and extend this one for future puzzles :p
2021-12-09 15:56:07 +0100nebu(~user@user/wavion)
2021-12-09 15:56:09 +0100 <byorgey> merijn: indeed
2021-12-09 15:56:22 +0100smartin(~Thunderbi@88.135.18.171)
2021-12-09 15:56:45 +0100 <byorgey> fizbin: meh, I just say runhaskell 09.hs < input or whatever, I can't be bothered to do anything fancy =)
2021-12-09 15:57:38 +0100Widget(~widget@2a04:ee41:6:70cd:e189:3667:bb4:f6ac) (Quit: Leaving...)
2021-12-09 15:57:55 +0100 <byorgey> The optional first argument approach sounds nice though.
2021-12-09 15:57:58 +0100 <merijn> byorgey: Biggest flaw in my map rendering is that I should probably extend it to automatically detect cell size and account for that, so I can use multi character values instead of the current Char labelling which...does not quite work out for the big problems
2021-12-09 15:58:13 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 240 seconds)
2021-12-09 15:58:18 +0100shapr(~user@pool-100-36-247-68.washdc.fios.verizon.net)
2021-12-09 15:58:21 +0100 <merijn> because there's basins with characters that fuck up my terminal xD
2021-12-09 15:58:26 +0100 <byorgey> lol
2021-12-09 15:59:23 +0100 <merijn> I've been thinking about making a library for my parse wrapper, getting the file and things like rendering maps, since those are so frequent with AOC. OTOH, that'd stop being standalone :\
2021-12-09 15:59:53 +0100 <merijn> We'll see. This is probably the first year I actually finish AOC, so I will actually need to keep using code the entire time :p
2021-12-09 16:00:50 +0100 <fizbin> byorgey: Especially because you write that code once and then copy/paste. Just don't forget to update the name of the default input file like I did on day5...
2021-12-09 16:01:04 +0100nebu(~user@user/wavion) (Ping timeout: 256 seconds)
2021-12-09 16:01:13 +0100 <merijn> fizbin: See, my megaparsec parsers would catch that ;)
2021-12-09 16:01:36 +0100 <fizbin> Oh, I mean, I didn't get the wrong answer and submit it, I got errors.
2021-12-09 16:02:22 +0100 <fizbin> It's just that errors are naturally showing up at 12:30-1am local time because of where I am and my brain takes a while to think through what might cause things like that.
2021-12-09 16:02:52 +0100 <merijn> I don't even try to compete, tbh
2021-12-09 16:02:56 +0100fizbindoes not have a brain that functions at peak at that hour.
2021-12-09 16:03:03 +0100 <merijn> puzzles are posted at 6 AM local time. Screw that
2021-12-09 16:03:16 +0100 <merijn> I refuse to acknowledge the existence of times before 9:00
2021-12-09 16:04:09 +0100 <fizbin> I haven't gotten any main board points since 2018. I got three sub-200 "part 2" times in 2020, and have gotten one so far this year.
2021-12-09 16:04:38 +0100 <fizbin> Last night was bad though. Sub-2000, but over 1500
2021-12-09 16:05:14 +0100 <fizbin> I feel like the number of people doing them as the problems come out jumped by a lot in 2019.
2021-12-09 16:10:01 +0100cfricke(~cfricke@user/cfricke)
2021-12-09 16:11:04 +0100acidjnk_new(~acidjnk@p200300d0c7271e730cb547fb259b1246.dip0.t-ipconnect.de) (Ping timeout: 265 seconds)
2021-12-09 16:13:22 +0100sprout(~quassel@2a02:a467:ccd6:1:2835:2428:a8d4:1d95)
2021-12-09 16:16:59 +0100euandreh(~euandreh@2804:14c:33:9fe5:cd28:ecf9:b8a2:d95a) (Ping timeout: 268 seconds)
2021-12-09 16:18:14 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2021-12-09 16:21:59 +0100fizbinsets up a github repo for aoc2021, like all the cool kids. https://github.com/fizbin/aoc2021/blob/main/aoc9.hs
2021-12-09 16:22:26 +0100 <fizbin> If the formatting looks weird, that's all hindent's doing.
2021-12-09 16:22:30 +0100 <yushyin> very cool, much wow
2021-12-09 16:25:04 +0100 <merijn> fizbin: Isn't multiset just
2021-12-09 16:25:10 +0100 <merijn> "Map v Int"? :p
2021-12-09 16:25:40 +0100 <fizbin> merijn: It's "Map v Int" with loads of convenience functions on it.
2021-12-09 16:26:01 +0100 <merijn> fizbin: I mean, you can just use "M.fromListWith (+) . map (,1)" like I do ;)
2021-12-09 16:26:16 +0100 <fizbin> Sure. For this problem it's a bit overkill.
2021-12-09 16:27:30 +0100 <fizbin> But I saw the nice uses people used it for on day 6, so I wanted to start using it for those times when it'd be convenient.
2021-12-09 16:28:25 +0100pfurla(~pfurla@2804:14d:5c81:4104:25b5:2708:65a9:4e7d) (Quit: gone to sleep. ZZZzzz…)
2021-12-09 16:29:08 +0100 <merijn> fizbin: I mean, for Day6 it's even more overkill xD
2021-12-09 16:29:11 +0100n3t(n3t@s45.mydevil.net) (Changing host)
2021-12-09 16:29:11 +0100n3t(n3t@user/n3t)
2021-12-09 16:29:26 +0100 <fizbin> e.g. "MS.concatMap func myms" is nicer than "M.fromList (+) $ concatMap func $ M.toList mymap", plus the signature of "func" is nicer.
2021-12-09 16:30:02 +0100 <fizbin> simulate = Data.MultiSet.concatMap (\i -> if i == 0 then [6, 8] else [i - 1])
2021-12-09 16:30:28 +0100 <merijn> fizbin: https://github.com/merijn/AdventOfCode/blob/master/Day6.hs#L45-L51 :)
2021-12-09 16:32:48 +0100meinside(uid24933@id-24933.helmsley.irccloud.com)
2021-12-09 16:36:16 +0100 <fizbin> I'd argue that the one line is faster to type and also easier to read because it follows the flow of the problem rather than needing the mentally invert the "this on day N becomes this on day N+1" story structure to work out "this on day N+1 came form this and that on day N"
2021-12-09 16:37:03 +0100 <fizbin> But yeah, I did day 6 with just Data.Map: https://github.com/fizbin/aoc2021/blob/main/aoc6.hs#L10-L14
2021-12-09 16:37:07 +0100doyougnu(~doyougnu@c-73-25-202-122.hsd1.or.comcast.net)
2021-12-09 16:39:09 +0100hololeap(~hololeap@user/hololeap) (Ping timeout: 276 seconds)
2021-12-09 16:39:34 +0100 <fizbin> Huh. I could trim my imports on day 6 down to just Data.Map and System.Environment. Oh well.
2021-12-09 16:42:07 +0100Cajun(~Cajun@user/cajun) (Quit: Client closed)
2021-12-09 16:42:27 +0100JoshuaBelden(~JoshuaBel@131.150.106.37)
2021-12-09 16:42:42 +0100 <kuribas> Exception instance is rather infectious with Typeable...
2021-12-09 16:42:52 +0100 <kuribas> if the exception type takes a type variable.
2021-12-09 16:45:17 +0100euandreh(~euandreh@2804:14c:33:9fe5:1b4:2cec:47c3:871e)
2021-12-09 16:45:32 +0100 <merijn> kuribas: Don't make parametric exceptions, then? >.>
2021-12-09 16:45:49 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 240 seconds)
2021-12-09 16:45:53 +0100 <kuribas> merijn: it is nice to give some context...
2021-12-09 16:46:20 +0100 <kuribas> or I pass the context as a string...
2021-12-09 16:47:33 +0100jinsun(~quassel@user/jinsun) (Quit: https://quassel-irc.org - Chat comfortably. Anywhere.)
2021-12-09 16:47:55 +0100jinsun(~quassel@user/jinsun)
2021-12-09 16:50:42 +0100motherfsck(~motherfsc@user/motherfsck) (Ping timeout: 265 seconds)
2021-12-09 16:50:54 +0100cfricke(~cfricke@user/cfricke) (Ping timeout: 268 seconds)
2021-12-09 16:54:02 +0100JoshuaBelden(~JoshuaBel@131.150.106.37) (Quit: Leaving...)
2021-12-09 16:54:33 +0100burnsidesLlama(~burnsides@dhcp168-015.wadham.ox.ac.uk)
2021-12-09 16:59:11 +0100derelicttetrahedron
2021-12-09 16:59:17 +0100nvmd(~nvmd@user/nvmd)
2021-12-09 16:59:23 +0100synthmeat(~synthmeat@user/synthmeat) (Quit: WeeChat 3.0)
2021-12-09 17:00:47 +0100synthmeat(~synthmeat@user/synthmeat)
2021-12-09 17:02:14 +0100synthmeat(~synthmeat@user/synthmeat) (Client Quit)
2021-12-09 17:05:58 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 17:07:49 +0100gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-12-09 17:08:21 +0100pfurla(~pfurla@2804:14d:5c81:4104:25b5:2708:65a9:4e7d)
2021-12-09 17:08:29 +0100hololeap(~hololeap@user/hololeap)
2021-12-09 17:09:15 +0100synthmeat(~synthmeat@user/synthmeat)
2021-12-09 17:11:07 +0100synthmeat(~synthmeat@user/synthmeat) (Client Quit)
2021-12-09 17:11:52 +0100mncheck(~mncheck@193.224.205.254) (Quit: Leaving)
2021-12-09 17:12:49 +0100motherfsck(~motherfsc@user/motherfsck)
2021-12-09 17:15:15 +0100chele(~chele@user/chele) (Remote host closed the connection)
2021-12-09 17:17:05 +0100 <fizbin> Most of my haskell AOC solutions are just translations of the python versions, but I do like my alternate day 8 solution of https://github.com/fizbin/aoc2021/blob/main/aoc8b.hs which uses the List monad to do logic programming.
2021-12-09 17:18:17 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:48df:3af4:d67f:b5a0) (Quit: WeeChat 2.8)
2021-12-09 17:20:14 +0100InternetCitizen(~fuzzypixe@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-12-09 17:20:15 +0100Neuromancer(~Neuromanc@user/neuromancer)
2021-12-09 17:20:58 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2021-12-09 17:21:07 +0100synthmeat(~synthmeat@user/synthmeat)
2021-12-09 17:21:54 +0100 <maerwald[m]> You guys make me feel guilty for being too lazy doing AoC
2021-12-09 17:24:35 +0100 <yushyin> blame it on your rsi syndrome, it is healthier not to do aoc
2021-12-09 17:28:03 +0100 <fizbin> It's definitely healthier not to for people in the US-East timezone
2021-12-09 17:30:46 +0100WHatever666(~fuzzypixe@tchebychev.ensimag.fr)
2021-12-09 17:30:49 +0100InternetCitizen(~fuzzypixe@eth-west-pareq2-46-193-4-100.wb.wifirst.net) (Ping timeout: 265 seconds)
2021-12-09 17:33:06 +0100pfurla(~pfurla@2804:14d:5c81:4104:25b5:2708:65a9:4e7d) (Quit: gone to sleep. ZZZzzz…)
2021-12-09 17:34:00 +0100cosimone(~user@2001:b07:ae5:db26:c24a:d20:4d91:1e20)
2021-12-09 17:37:49 +0100alx741(~alx741@186.178.108.192) (Ping timeout: 240 seconds)
2021-12-09 17:40:20 +0100_ht(~quassel@82-169-194-8.biz.kpn.net)
2021-12-09 17:40:31 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f80d:43f5:ddf4:fb26)
2021-12-09 17:41:17 +0100 <sm> resist maerwald! just say no
2021-12-09 17:41:26 +0100curiousgay(~curiousga@77-120-141-90.kha.volia.net)
2021-12-09 17:41:45 +0100max22-(~maxime@2a01cb0883359800d97fa420b95dd877.ipv6.abo.wanadoo.fr) (Quit: Leaving)
2021-12-09 17:42:17 +0100jakalx(~jakalx@base.jakalx.net) (Error from remote client)
2021-12-09 17:46:52 +0100gaff(~gaff@49.207.222.161)
2021-12-09 17:46:55 +0100jakalx(~jakalx@base.jakalx.net)
2021-12-09 17:47:21 +0100maroloccio(~marolocci@151.53.155.184) (Quit: WeeChat 3.0)
2021-12-09 17:47:38 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-12-09 17:47:38 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-12-09 17:47:38 +0100wroathe(~wroathe@user/wroathe)
2021-12-09 17:49:47 +0100 <gaff> when you run cabal v2-repl :target, and have some module `m` in scope at GHCi prompt, shouldn't whatever exported functions in modules module `m` imports be visible at GHCi prompt?
2021-12-09 17:51:01 +0100alx741(~alx741@157.100.93.160)
2021-12-09 17:51:07 +0100kaol_kaol
2021-12-09 17:51:58 +0100 <sm> unless module m re-exports them.. you will need to be "inside" module m, ie seeing all bindings within m. The command is `:m +*M`
2021-12-09 17:52:34 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 265 seconds)
2021-12-09 17:52:47 +0100xff0x(~xff0x@2001:1a81:5338:9c00:c1d:978d:6bc0:7433) (Ping timeout: 252 seconds)
2021-12-09 17:53:28 +0100 <xerox> > foldl f a [b,c,d]
2021-12-09 17:53:29 +0100 <lambdabot> f (f (f a b) c) d
2021-12-09 17:53:36 +0100xff0x(~xff0x@2001:1a81:5338:9c00:1be4:4471:6bbc:3532)
2021-12-09 17:53:54 +0100 <xerox> I forget what the module is that gives those show instances, something like simple-expression I thought
2021-12-09 17:54:04 +0100 <gaff> for example, if module `m` (the one in scope in GHCi) imports `Test.QuickCheck`, then in GHCi,, :t quickCheck should show the type information, correct?
2021-12-09 17:54:30 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-12-09 17:54:46 +0100 <xerox> simple reflect
2021-12-09 17:55:01 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 17:55:14 +0100 <monochrom> BTW deliberately confusing (or not):
2021-12-09 17:55:22 +0100 <monochrom> > foldr f z [a,b,c,d,e,f]
2021-12-09 17:55:24 +0100 <lambdabot> f a (f b (f c (f d (f e (f f z)))))
2021-12-09 17:56:02 +0100 <monochrom> Trick question: Expand (x-a)(x-b)(x-c)...(x-z)
2021-12-09 17:56:19 +0100 <monochrom> Answer: it has an (x-x) so the whole thing is 0 >:)
2021-12-09 17:56:20 +0100 <xerox> neat
2021-12-09 17:56:53 +0100nebu(~user@user/wavion)
2021-12-09 17:57:57 +0100 <gaff> sm: thanks. that worked. i didn't know that!
2021-12-09 17:58:13 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 240 seconds)
2021-12-09 17:58:54 +0100jippiedoe(~david@2a02-a44c-e14e-1-9f6f-678f-3cd5-9f8c.fixed6.kpn.net) (Quit: Leaving)
2021-12-09 17:59:23 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 17:59:40 +0100slowButPresent(~slowButPr@user/slowbutpresent)
2021-12-09 18:00:07 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-12-09 18:00:10 +0100 <gaff> monochrom: that is nice
2021-12-09 18:00:33 +0100gaff(~gaff@49.207.222.161) ()
2021-12-09 18:00:50 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 18:01:58 +0100max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr)
2021-12-09 18:02:14 +0100nebu(~user@user/wavion) (Ping timeout: 265 seconds)
2021-12-09 18:03:47 +0100lavaman(~lavaman@98.38.249.169) (Ping timeout: 252 seconds)
2021-12-09 18:04:14 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Read error: Connection reset by peer)
2021-12-09 18:05:38 +0100 <int-e> dminuoso: https://paste.tomsmeding.com/WoV7elom confirms my suspicion that writing polymorphic PrimMonad code is bad for optimization
2021-12-09 18:05:59 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-12-09 18:06:31 +0100 <tomsmeding> xerox: this? https://hackage.haskell.org/package/simple-reflect
2021-12-09 18:06:31 +0100 <int-e> (unless things are small enough to be fully inlined to where the actual monad is known)
2021-12-09 18:06:39 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 18:06:51 +0100 <geekosaur> yes
2021-12-09 18:07:26 +0100pfurla(~pfurla@2804:14d:5c81:4104:25b5:2708:65a9:4e7d)
2021-12-09 18:07:46 +0100 <tomsmeding> what's interesting is that searching for Debug.SimpleReflect in the lambdabot repo on github doesn't give any hits
2021-12-09 18:08:09 +0100 <geekosaur> @where L.hs
2021-12-09 18:08:09 +0100 <lambdabot> what lambdabot has in scope is at https://silicon.int-e.eu/lambdabot/State/Pristine.hs
2021-12-09 18:08:12 +0100 <int-e> dminuoso: PrimMonad still solves a problem though: how to avoid exporting all primitives twice, once for ST s and once for IO. (The cost is some extra `cast`-s in the core, which hopefully don't hurt)
2021-12-09 18:08:21 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f80d:43f5:ddf4:fb26) (Remote host closed the connection)
2021-12-09 18:08:45 +0100emf(~emf@2620:10d:c091:480::1:58ea)
2021-12-09 18:11:08 +0100 <int-e> tomsmeding: its in the libera branch (which I hardly ever mention because I force-push things there)
2021-12-09 18:11:25 +0100 <tomsmeding> int-e: ah
2021-12-09 18:11:49 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 240 seconds)
2021-12-09 18:12:21 +0100 <int-e> I really need to get on updating lambdabot for 9.0 (maybe 9.2, depending on the level of pain).
2021-12-09 18:12:37 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 18:14:10 +0100JoshuaBelden(~JoshuaBel@131.150.106.37)
2021-12-09 18:17:10 +0100synthmeat(~synthmeat@user/synthmeat) (Quit: WeeChat 3.0)
2021-12-09 18:18:05 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-12-09 18:18:25 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 18:18:49 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f80d:43f5:ddf4:fb26)
2021-12-09 18:20:07 +0100 <int-e> > unwords $ map (\x -> printf "%.2f" (190-x/18)) [3361,3351,3322,3299,3242,3223,3209,3205,3185,3182] -- still not settled though, cyphase seems to have prioritized sleep over finishing part 2 (can still reach rank 6)
2021-12-09 18:20:08 +0100 <lambdabot> "3.28 3.83 5.44 6.72 9.89 10.94 11.72 11.94 13.06 13.22"
2021-12-09 18:20:23 +0100Akiva(~Akiva@user/Akiva)
2021-12-09 18:21:33 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 18:23:35 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-12-09 18:23:51 +0100 <xerox> oh no I'll get bumped off if he finishes
2021-12-09 18:24:22 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 18:24:53 +0100waleee(~waleee@h-98-128-229-110.NA.cust.bahnhof.se) (Quit: WeeChat 3.3)
2021-12-09 18:27:23 +0100waleee(~waleee@2001:9b0:21d:fc00:398f:b003:b90d:acf4)
2021-12-09 18:27:49 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 18:28:59 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f80d:43f5:ddf4:fb26) (Remote host closed the connection)
2021-12-09 18:29:23 +0100cfricke(~cfricke@user/cfricke)
2021-12-09 18:29:32 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-12-09 18:30:23 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 18:32:22 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 256 seconds)
2021-12-09 18:33:36 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-12-09 18:33:36 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 18:33:51 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f80d:43f5:ddf4:fb26)
2021-12-09 18:35:03 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-12-09 18:35:41 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 252 seconds)
2021-12-09 18:36:19 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 18:36:23 +0100synthmeat(~synthmeat@user/synthmeat)
2021-12-09 18:37:10 +0100kupi(uid212005@id-212005.hampstead.irccloud.com) (Quit: Connection closed for inactivity)
2021-12-09 18:37:31 +0100zebrag(~chris@user/zebrag)
2021-12-09 18:38:00 +0100xff0x(~xff0x@2001:1a81:5338:9c00:1be4:4471:6bbc:3532) (Ping timeout: 265 seconds)
2021-12-09 18:38:19 +0100max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr) (Remote host closed the connection)
2021-12-09 18:38:53 +0100xff0x(~xff0x@2001:1a81:5338:9c00:d04b:38a4:ed4b:d288)
2021-12-09 18:39:07 +0100max22-(~maxime@lfbn-ren-1-762-224.w81-53.abo.wanadoo.fr)
2021-12-09 18:41:39 +0100Guest48(~Guest48@wireless-student-pt3-240-131.lut.ac.uk)
2021-12-09 18:41:54 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 268 seconds)
2021-12-09 18:42:13 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 18:45:39 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Remote host closed the connection)
2021-12-09 18:47:10 +0100Kevin578(~Kevin578@pool-96-237-112-198.bstnma.fios.verizon.net) (Remote host closed the connection)
2021-12-09 18:47:23 +0100d34df00d(~d34df00d@2600:1700:8c60:3a10::48) (Remote host closed the connection)
2021-12-09 18:49:05 +0100dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-12-09 18:53:00 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 268 seconds)
2021-12-09 18:54:20 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 18:54:55 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de) (Ping timeout: 265 seconds)
2021-12-09 18:55:30 +0100Guest18(~Guest18@client-8-71.eduroam.oxuni.org.uk)
2021-12-09 18:56:47 +0100Guest18(~Guest18@client-8-71.eduroam.oxuni.org.uk) (Client Quit)
2021-12-09 18:56:52 +0100cfricke(~cfricke@user/cfricke) (Quit: WeeChat 3.3)
2021-12-09 18:59:46 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 260 seconds)
2021-12-09 19:00:30 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 19:01:27 +0100lky(~hbghlyj@client-8-71.eduroam.oxuni.org.uk)
2021-12-09 19:02:53 +0100Gurkenglas(~Gurkengla@dslb-002-203-144-204.002.203.pools.vodafone-ip.de)
2021-12-09 19:03:32 +0100dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Ping timeout: 256 seconds)
2021-12-09 19:04:58 +0100Guest48(~Guest48@wireless-student-pt3-240-131.lut.ac.uk) (Quit: Client closed)
2021-12-09 19:05:04 +0100teo(~teo@user/teo) (Ping timeout: 265 seconds)
2021-12-09 19:05:48 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-12-09 19:05:55 +0100whatif(~user@2400:8902::f03c:92ff:fe60:98d8) (Remote host closed the connection)
2021-12-09 19:06:06 +0100whatif(~user@2400:8902::f03c:92ff:fe60:98d8)
2021-12-09 19:06:33 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 19:11:50 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 265 seconds)
2021-12-09 19:12:32 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-12-09 19:12:33 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 19:13:49 +0100k60``(~user@static.100.218.46.78.clients.your-server.de) (Ping timeout: 240 seconds)
2021-12-09 19:16:48 +0100k60``(~user@static.100.218.46.78.clients.your-server.de)
2021-12-09 19:17:42 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-12-09 19:18:09 +0100lky(~hbghlyj@client-8-71.eduroam.oxuni.org.uk) (Quit: Leaving)
2021-12-09 19:18:18 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 19:23:05 +0100tzh(~tzh@c-24-21-73-154.hsd1.wa.comcast.net)
2021-12-09 19:23:56 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 256 seconds)
2021-12-09 19:28:57 +0100justsomeguy(~justsomeg@user/justsomeguy)
2021-12-09 19:34:01 +0100motherfsck(~motherfsc@user/motherfsck) (Read error: Connection reset by peer)
2021-12-09 19:37:35 +0100 <hololeap> deriving stock instance (forall f. Functor f => Functor (t f), forall f. Foldable f => Foldable (t f), forall f. Traversable f => Traversable (t f)) => Traversable (Row t)
2021-12-09 19:37:42 +0100 <hololeap> at least I know it's possible now
2021-12-09 19:37:43 +0100motherfsck(~motherfsc@user/motherfsck)
2021-12-09 19:39:35 +0100pfurla(~pfurla@2804:14d:5c81:4104:25b5:2708:65a9:4e7d) (Quit: gone to sleep. ZZZzzz…)
2021-12-09 19:40:22 +0100k60``(~user@static.100.218.46.78.clients.your-server.de) (Ping timeout: 256 seconds)
2021-12-09 19:41:42 +0100 <EvanR> with enough Functor and Foldable you can do anything it seems
2021-12-09 19:41:56 +0100 <EvanR> maybe that's why mapreduce is a buzzword
2021-12-09 19:44:01 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 19:44:42 +0100 <hololeap> I kind of wish "forall f. Traversable f => Traversable (t f)" implied the other two with QuantifiedConstraints, but I don't understand the underlaying type theory well enough to know if that's a reasonable feature
2021-12-09 19:50:01 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-12-09 19:50:33 +0100 <awpr> that should imply `forall f. Traversable f => Functor (t f)` etc., but the left side of the `=>` is effectively contravariant, and that doesn't in turn imply `forall f. Functor f => Functor (t f)`
2021-12-09 19:52:02 +0100 <awpr> first one is saying the instance expects `Traversable f` in order for `t f` to be `Functor`, but trying to convert it to the second one would mean trying to solve `Functor (t f)` given only `Functor f`, which isn't enough to satisfy that instance's context
2021-12-09 19:52:08 +0100dhouthoo(~dhouthoo@178-117-36-167.access.telenet.be) (Quit: WeeChat 3.3)
2021-12-09 19:52:23 +0100 <cyphase> int-e, i knew going in to part 1 that i was going to be distracted, and it took me longer than it would have. then yea, i just decided to focus on the (pleasantly) distracting thing and leave part 2 for daylight
2021-12-09 19:54:03 +0100justsomeguy(~justsomeg@user/justsomeguy) (Ping timeout: 268 seconds)
2021-12-09 19:57:38 +0100nebu(~user@user/wavion)
2021-12-09 19:58:09 +0100 <EvanR> it's getting kind of brutal doing these at midnight xD
2021-12-09 19:58:24 +0100Kevin578(~Kevin578@pool-96-237-112-198.bstnma.fios.verizon.net)
2021-12-09 20:03:02 +0100nebu(~user@user/wavion) (Ping timeout: 256 seconds)
2021-12-09 20:04:57 +0100 <dsal> ghc: panic! (the 'impossible' happened)
2021-12-09 20:05:00 +0100 <dsal> that's kinda my thing.
2021-12-09 20:05:03 +0100 <dsal> I make the impossible happen.
2021-12-09 20:05:43 +0100econo(uid147250@user/econo)
2021-12-09 20:06:08 +0100 <boxscape> % GHC.Utils.Misc.only []
2021-12-09 20:06:08 +0100 <yahb> boxscape: *** Exception: ghc: panic! (the 'impossible' happened); (GHC version 9.0.1:; Util: only; Please report this as a GHC bug: https://www.haskell.org/ghc/reportabug
2021-12-09 20:06:11 +0100 <int-e> . o O ( asserted to be a failure )
2021-12-09 20:07:11 +0100WilliamJ(~WilliamJ@wireless-student-pt10-182-232.lut.ac.uk)
2021-12-09 20:07:13 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 20:08:25 +0100 <EvanR> I hate it when impossible happens
2021-12-09 20:08:30 +0100 <EvanR> it's the worst
2021-12-09 20:09:06 +0100 <dsal> EvanR: don't let your dreams be dreams
2021-12-09 20:09:15 +0100 <EvanR> almost as bad when necessarily doesn't happen
2021-12-09 20:13:52 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f80d:43f5:ddf4:fb26) (Remote host closed the connection)
2021-12-09 20:15:16 +0100nebu(~user@user/wavion)
2021-12-09 20:15:53 +0100eggplantade(~Eggplanta@2600:1700:bef1:5e10:f80d:43f5:ddf4:fb26)
2021-12-09 20:16:15 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 268 seconds)
2021-12-09 20:18:05 +0100sluigi(~sluigi@18.31.9.106)
2021-12-09 20:19:42 +0100 <WilliamJ> hi guys, i'm new to haskell and have a task to program a function where it takes the length and width of a rectangle and the number of steps, for example putStr(rectangles 2 3 3) would be
2021-12-09 20:19:42 +0100 <WilliamJ> ***
2021-12-09 20:19:43 +0100 <WilliamJ> ***
2021-12-09 20:19:43 +0100 <WilliamJ>    ******
2021-12-09 20:19:44 +0100 <WilliamJ>    ******
2021-12-09 20:19:44 +0100 <WilliamJ>       *********
2021-12-09 20:19:45 +0100 <WilliamJ>       *********
2021-12-09 20:19:45 +0100 <WilliamJ> I have managed to program an initial function to get the initial rectangle but stuck on how to do the other 2, the code is here https://paste.tomsmeding.com/OJQyGfBT any help would be appreciated :)
2021-12-09 20:20:29 +0100 <monochrom> What does "number of step" mean?
2021-12-09 20:20:49 +0100curiousgay(~curiousga@77-120-141-90.kha.volia.net) (Quit: Leaving)
2021-12-09 20:20:54 +0100 <EvanR> is that ascii art accurate
2021-12-09 20:21:07 +0100 <WilliamJ> there is 3 rectangles outputted
2021-12-09 20:21:16 +0100 <WilliamJ> steps is the number
2021-12-09 20:21:41 +0100 <monochrom> That doesn't explain anything.
2021-12-09 20:21:49 +0100 <monochrom> Why are there 3 rectangles?
2021-12-09 20:21:57 +0100 <monochrom> Why are some of them bigger?
2021-12-09 20:22:05 +0100 <monochrom> Why are some of them indented?
2021-12-09 20:22:53 +0100 <monochrom> I only know that a rectangle has width and height. What is "step" doing with a rectangle?
2021-12-09 20:23:11 +0100 <aplainzetakind> It's obvious. The first parameter is the height, the second is the number of rectangles, and the third is the increase both in indentation and width as well as the initial width. What's the problem?
2021-12-09 20:23:25 +0100 <EvanR> so it is accurate
2021-12-09 20:23:43 +0100 <WilliamJ> Oh sorry, ok so, each step there will be another rectangle created. On each step the width will be the width of the last one + the width inputted by the user step is basically how many rectangles there will be, the indentation therefore is the width of the last rectangle sorry for not explaining
2021-12-09 20:23:52 +0100 <WilliamJ> currently my code only outputs the first rectangle
2021-12-09 20:23:58 +0100 <monochrom> No, it is non-obvious. What not three kinds of steps, one for indentation, one for increase in width, one for increase in height
2021-12-09 20:24:15 +0100 <EvanR> given the picture is accurate, it's a simple IQ test to figure the rest out
2021-12-09 20:24:23 +0100 <monochrom> And for that matter, why linear growth for any of them, why not logarithmic growth or quadratic growth
2021-12-09 20:24:33 +0100 <aplainzetakind> monochrom: I was being sarcastic.
2021-12-09 20:24:44 +0100 <WilliamJ> What I am confused about is how do I make it repeat it with the whitespace and make the width get bigger by that increment each time?
2021-12-09 20:24:46 +0100 <monochrom> OK sorry, thanks.
2021-12-09 20:24:48 +0100 <aplainzetakind> WilliamJ: The indentation is not the width of the previous rectangle though.
2021-12-09 20:25:08 +0100 <WilliamJ> Do I mean length? Habe I gotten them mixed up
2021-12-09 20:25:18 +0100 <EvanR> width, height
2021-12-09 20:25:19 +0100 <WilliamJ> The 2nd rectangle is meant to be indented by 3 whitespace
2021-12-09 20:25:35 +0100 <aplainzetakind> And the third?
2021-12-09 20:25:37 +0100 <WilliamJ> 6
2021-12-09 20:25:38 +0100 <EvanR> length is for rods and line segments
2021-12-09 20:25:43 +0100 <aplainzetakind> But why?
2021-12-09 20:25:47 +0100 <aplainzetakind> What does it all mean?
2021-12-09 20:26:35 +0100 <WilliamJ> What does what mean, the output or the indentation? It's meant to be an ascii art creator with asterixes, as EvanR mentioned before
2021-12-09 20:26:47 +0100 <WilliamJ> the Indentation is part of it
2021-12-09 20:26:59 +0100 <WilliamJ> sorry if this is unclear
2021-12-09 20:27:07 +0100 <int-e> aplainzetakind: try ##philosophy ;-)
2021-12-09 20:27:47 +0100 <aplainzetakind> In any case, I think you should first write a function f i w h, which outputs a single rectangle of the given indentation width and height, and use that to output multiple such rectangles.
2021-12-09 20:28:58 +0100sluigi(~sluigi@18.31.9.106) (Quit: Client closed)
2021-12-09 20:29:30 +0100 <monochrom> https://esmemes.com/t/what-does-it-mean-to-be-a-good-person
2021-12-09 20:29:41 +0100 <WilliamJ> But on the task, it does not ask specifically for the indentation to be given as an input, it is worked out through the width of the last one
2021-12-09 20:30:24 +0100 <WilliamJ> hence on the example I gave, it went 3 whitespace, 6 whitespace.
2021-12-09 20:30:31 +0100 <EvanR> ah yes, the ancient philosopher esmemes
2021-12-09 20:31:26 +0100 <aplainzetakind> WilliamJ: I understand, you can use the proposed f above with values of i computed in the main task-fulfilling function.
2021-12-09 20:33:07 +0100 <monochrom> Write a helper function that makes one rectangle of height, width, indentation controlled by parameters.
2021-12-09 20:33:34 +0100 <monochrom> Now you just have to call that function multiple times, each time with larger numbers.
2021-12-09 20:33:36 +0100 <monochrom> "just"
2021-12-09 20:33:55 +0100 <WilliamJ> ok I got it working for the first place of the function, not sure why it isnt working on the other lines.
2021-12-09 20:34:00 +0100 <WilliamJ> What is a helper function?
2021-12-09 20:34:19 +0100 <monochrom> A function that the assignment doesn't directly say you have to write.
2021-12-09 20:34:33 +0100 <monochrom> But the assignment would be trivial if you wrote it first.
2021-12-09 20:34:48 +0100 <monochrom> This is why the assignment keeps it a secret.
2021-12-09 20:34:54 +0100JoshuaBelden(~JoshuaBel@131.150.106.37) (Quit: Leaving...)
2021-12-09 20:35:00 +0100 <monochrom> Can't tell every student how to get full marks.
2021-12-09 20:35:08 +0100 <aplainzetakind> Only selected ones?
2021-12-09 20:35:27 +0100 <WilliamJ> monochrom haha obviously, we have not been introduced to them yet.
2021-12-09 20:35:41 +0100Midjak(~Midjak@may53-1-78-226-116-92.fbx.proxad.net)
2021-12-09 20:35:41 +0100 <WilliamJ> aplainzetakind the first line
2021-12-09 20:35:53 +0100 <WilliamJ> rectangle :: Int -> Int -> Int -> String
2021-12-09 20:35:53 +0100 <WilliamJ> rectangle i m n = (replicate i ' ' ++ unlines(replicate m(replicate n '*')))
2021-12-09 20:36:28 +0100 <monochrom> If your rectangle has 10 lines, clearly you have 10 lines to indent.
2021-12-09 20:36:30 +0100 <aplainzetakind> Not quite.
2021-12-09 20:36:31 +0100 <monochrom> "clearly"
2021-12-09 20:37:40 +0100 <WilliamJ> I tried it within the other brackets but it did not work so I put it on the outside hence I got that solution, do I need to do something with the unlines function?
2021-12-09 20:38:06 +0100 <aplainzetakind> WilliamJ: Are you actually trying what the above function does in the repl?
2021-12-09 20:38:16 +0100 <WilliamJ> I tried it in GHCI
2021-12-09 20:38:24 +0100 <aplainzetakind> And did you get what you wanted?
2021-12-09 20:38:32 +0100 <WilliamJ>    ***
2021-12-09 20:38:32 +0100 <WilliamJ> ***
2021-12-09 20:38:33 +0100 <WilliamJ> I got this
2021-12-09 20:39:00 +0100 <aplainzetakind> So you can see what's wrong with it then.
2021-12-09 20:39:41 +0100 <WilliamJ> Yeah, I thought at first I had to group it with the other replicate functions but it didnt work so I tried that solution and I got this
2021-12-09 20:40:10 +0100 <WilliamJ> I know why this isnt working though
2021-12-09 20:40:23 +0100 <WilliamJ> as I am concatinating with the first line only, it is not being repeated on every line
2021-12-09 20:41:53 +0100 <aplainzetakind> In what way did it not work in the first try?
2021-12-09 20:42:03 +0100 <WilliamJ> unlines(replicate i ' '(replicate m(replicate n '*'))) I tried this the first time
2021-12-09 20:42:39 +0100 <WilliamJ> I receive an error saying it could not match [[Char]] -> [String]
2021-12-09 20:43:02 +0100 <aplainzetakind> Figuring out what those type errors are telling you is a very important skill.
2021-12-09 20:43:23 +0100Erutuon(~Erutuon@user/erutuon)
2021-12-09 20:43:38 +0100 <aplainzetakind> Around that line you can find exactly what it expected to be of that type and what it found instead.
2021-12-09 20:43:45 +0100 <WilliamJ> My actual type is [Char] which makes sense to me, but why is it telling me the expected type is [[char]]
2021-12-09 20:44:15 +0100 <aplainzetakind> Paste the whole error (not here, on a paste bin).
2021-12-09 20:44:23 +0100 <WilliamJ> (y)
2021-12-09 20:44:25 +0100 <geekosaur> @where paste
2021-12-09 20:44:26 +0100 <lambdabot> Help us help you: please paste full code, input and/or output at e.g. https://paste.tomsmeding.com
2021-12-09 20:44:54 +0100 <WilliamJ> https://paste.tomsmeding.com/gXYCtrZY
2021-12-09 20:45:25 +0100 <WilliamJ> Is it saying [[Char]] because I am trying to do 2 outputs of different characters? whitespace and asterix
2021-12-09 20:45:54 +0100 <aplainzetakind> It's sayin something clearer.
2021-12-09 20:46:09 +0100 <aplainzetakind> Lines 3 and 4
2021-12-09 20:46:25 +0100 <WilliamJ> Oh ok, I see
2021-12-09 20:47:04 +0100 <WilliamJ> So because these are all grouped together due to the type of replicate being that it is not possible?
2021-12-09 20:47:52 +0100dschrempf(~dominik@070-207.dynamic.dsl.fonira.net)
2021-12-09 20:49:17 +0100 <aplainzetakind> "grouped together" sounds a bit off.
2021-12-09 20:49:51 +0100 <monochrom> replicate wants 2 arguments. Why are you giving it 3?
2021-12-09 20:50:19 +0100 <aplainzetakind> If something like `f a b c` is supposed to be a valid expression, then f should take at least three arguments.
2021-12-09 20:50:39 +0100 <WilliamJ> I tried to give it 3 arguments as I thought in order to get the indentation on each line, they had to be together inside the same brackets but it seems that cannot be the case
2021-12-09 20:51:00 +0100 <aplainzetakind> Whitespace is function application.
2021-12-09 20:51:29 +0100Successus(~Successus@gateway/tor-sasl/successus) ()
2021-12-09 20:51:37 +0100 <WilliamJ> Oh ok, I see now
2021-12-09 20:51:43 +0100 <monochrom> Did you ever concatenation two strings "abc" and "def" but just coding up "abc" "def"?
2021-12-09 20:51:50 +0100 <monochrom> s/but/by/
2021-12-09 20:51:54 +0100 <aplainzetakind> You are trying to apply `replicate i ' '` to that thing that follows, but it's a String and does not take any arguments.
2021-12-09 20:52:04 +0100 <int-e> aplainzetakind: . o O { and braces and semicolons }
2021-12-09 20:52:34 +0100 <aplainzetakind> > succ; 5
2021-12-09 20:52:35 +0100 <WilliamJ> monochrom when using ++ for concatenation, no
2021-12-09 20:52:35 +0100 <lambdabot> <hint>:1:5: error: parse error on input ‘;’
2021-12-09 20:52:48 +0100 <aplainzetakind> int-e: Semicolons?
2021-12-09 20:52:54 +0100 <monochrom> OK so you know ++ for concatenation. Why didn't you use it?
2021-12-09 20:53:15 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-12-09 20:53:20 +0100 <int-e> > let x = 1;{- ordinarily you'd use a newline and indentation here, that is also whitespace-} y = 2 in x + y
2021-12-09 20:53:21 +0100 <lambdabot> 3
2021-12-09 20:53:21 +0100 <dsal> I think my impossible problem is from using stack to grab a thing out of git with different symbols but the same version number.
2021-12-09 20:53:27 +0100 <dsal> I've scorched the earth.
2021-12-09 20:53:27 +0100 <WilliamJ> I tried to use it at first when I did it on the outside of the group of brackets but it only did it on the first line, I have an idea now i shall give it a go
2021-12-09 20:53:53 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:36fe:413:d066:5593)
2021-12-09 20:53:54 +0100 <aplainzetakind> int-e: I should've said horizontal whitespace.
2021-12-09 20:54:00 +0100 <WilliamJ> ok, I just tried it and it gave me a different error
2021-12-09 20:54:23 +0100 <int-e> aplainzetakind: yeah my thought bubbles are not to be taken too seriously :-P
2021-12-09 20:54:25 +0100 <WilliamJ> I added ++ between unlines(replicate i ' '++(replicate m(replicate n '*')))
2021-12-09 20:54:44 +0100 <aplainzetakind> And that error must also be pretty clear if you give it a chance.
2021-12-09 20:54:49 +0100averell(~averell@user/averell) (Quit: .)
2021-12-09 20:55:25 +0100 <WilliamJ> Yes, it is talking about the types
2021-12-09 20:55:26 +0100 <monochrom> > zip"abc""def"
2021-12-09 20:55:28 +0100 <lambdabot> [('a','d'),('b','e'),('c','f')]
2021-12-09 20:55:38 +0100 <monochrom> No space, brace, semicolon.
2021-12-09 20:55:52 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net) (Remote host closed the connection)
2021-12-09 20:55:52 +0100 <monochrom> Now you have to add quotes to your list.
2021-12-09 20:55:53 +0100 <int-e> unlines (replicate i ' ' ++ replicate m (replicate n '*')) -- these extra spaces really improve readability though
2021-12-09 20:56:06 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-12-09 20:56:25 +0100 <aplainzetakind> Guys I did not say "ONLY whitespace is function application".
2021-12-09 20:56:32 +0100 <aplainzetakind> Add $ to the list then.
2021-12-09 20:56:36 +0100 <WilliamJ> So as it is no longer being applied to a string, it is talking about characters instead
2021-12-09 20:56:54 +0100 <WilliamJ> https://paste.tomsmeding.com/VDjqp1eA
2021-12-09 20:57:02 +0100 <int-e> aplainzetakind: eh calm down a little... we nitpick facts, not people, it's not personal
2021-12-09 20:57:33 +0100 <monochrom> > let snoc = flip (:) in snoc"bcd"'a'
2021-12-09 20:57:34 +0100 <lambdabot> "abcd"
2021-12-09 20:57:49 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2021-12-09 20:57:50 +0100 <aplainzetakind> I am calm, I'm nitpicking semantics in return.
2021-12-09 20:58:04 +0100 <int-e> Okay.
2021-12-09 20:58:08 +0100mc47(~mc47@xmonad/TheMC47)
2021-12-09 20:58:34 +0100 <monochrom> I was not nitpicking you, aplainzetakind. I was nitpicking int-e's list!
2021-12-09 20:58:54 +0100 <aplainzetakind> WilliamJ: What's not clear about lines 2--5?
2021-12-09 20:58:57 +0100 <monochrom> $ is no fun, though.
2021-12-09 20:59:06 +0100 <aplainzetakind> monochrom: & then?
2021-12-09 20:59:24 +0100 <int-e> monochrom: Hmm, why though? Whitespace doesn't turn into quotes...
2021-12-09 20:59:41 +0100 <WilliamJ> Ok, I got it running but it does not work as expected
2021-12-09 20:59:42 +0100 <int-e> monochrom: tbf there's some ambiguity in what that list was
2021-12-09 20:59:43 +0100 <monochrom> Perhaps quotes turn into whitespace?
2021-12-09 21:00:11 +0100 <int-e> monochrom: again that would be irrelevant
2021-12-09 21:00:11 +0100 <monochrom> Consider the zip"abc""def" example.
2021-12-09 21:00:19 +0100 <WilliamJ> I made the single quotes into double quotes but when I run the program, it outputs the whitespace and separate lines and then the rectangles
2021-12-09 21:00:39 +0100 <aplainzetakind> You did not read the error.
2021-12-09 21:01:03 +0100 <aplainzetakind> Lines 4 and 5 in what you pasted.
2021-12-09 21:01:13 +0100geekosaurthinks the whole "function application" subthread here can only bve explained in terms of tokens, not what characters count as "application"
2021-12-09 21:01:14 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-12-09 21:01:28 +0100 <aplainzetakind> Don't blindly change things around and hope it works out somehow.
2021-12-09 21:01:30 +0100 <WilliamJ> Yes, but I don't really understand what it is asking me aplainzetakind
2021-12-09 21:02:30 +0100 <aplainzetakind> (++) concatenates two Strings, and a String is just a [Char], but the second argument you gave (++) is not a String but a list of Strings. Reread the error to appreciate that this is what it's saying.
2021-12-09 21:02:31 +0100nvmd(~nvmd@user/nvmd) (Quit: Later, nerds.)
2021-12-09 21:02:36 +0100curiousgay(~curiousga@77-120-141-90.kha.volia.net)
2021-12-09 21:02:42 +0100 <geekosaur> :t replicate 2 (replicate 3 '*')
2021-12-09 21:02:43 +0100 <lambdabot> [[Char]]
2021-12-09 21:02:48 +0100 <monochrom> I am OK with blind changes. But you have to learn from the consequences.
2021-12-09 21:03:15 +0100 <zero> wuld there be any usefulness in distinguishing lazy Sets from strict Sets?
2021-12-09 21:03:27 +0100 <int-e> +1 on practicing to read ghc's error messages
2021-12-09 21:03:44 +0100 <geekosaur> zero, not really.
2021-12-09 21:03:51 +0100 <zero> why?
2021-12-09 21:03:55 +0100 <aplainzetakind> WilliamJ: To be more precise, (++) concatenates two lists of the same type, but here the first one encountered is a list of Char's.
2021-12-09 21:03:56 +0100 <WilliamJ> Yes I understand that ++ concatenates 2 strings but why would it not work? as they are both technically strings?
2021-12-09 21:04:02 +0100 <int-e> they can be scary, they can become very big, but they do follow regular patterns that you can learn to identify relevant information
2021-12-09 21:04:12 +0100 <monochrom> What do lazy Sets do? Why do strict Sets do?
2021-12-09 21:04:15 +0100 <aplainzetakind> No, it's telling you that the second one is not.
2021-12-09 21:04:26 +0100 <int-e> [String] isn't the same type as String
2021-12-09 21:04:29 +0100 <WilliamJ> How is '***' not a string?
2021-12-09 21:04:38 +0100 <geekosaur> zero, why would there be value to it when they'd just be duplicates of each other?
2021-12-09 21:04:40 +0100 <int-e> > '***'
2021-12-09 21:04:42 +0100 <lambdabot> <hint>:1:2: error: parse error on input ‘***’
2021-12-09 21:04:55 +0100juhp(~juhp@128.106.188.82) (Ping timeout: 252 seconds)
2021-12-09 21:04:58 +0100 <aplainzetakind> In the second argument of `(++)' namely replicate m (replicate n '*')
2021-12-09 21:05:07 +0100 <aplainzetakind> Is what it's saying.
2021-12-09 21:05:11 +0100 <geekosaur> > replicate 2 (replicate 3 '*')
2021-12-09 21:05:12 +0100 <lambdabot> ["***","***"]
2021-12-09 21:05:18 +0100 <WilliamJ> Ok, so have I done it in the incorrect place?
2021-12-09 21:05:21 +0100 <geekosaur> is the above a String?
2021-12-09 21:05:22 +0100 <monochrom> What is the type of replicate m (replicate n '*') ?
2021-12-09 21:05:28 +0100 <WilliamJ> No, that is a list geekosaur
2021-12-09 21:05:34 +0100 <zero> are Sets strict or lazy?
2021-12-09 21:05:41 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-12-09 21:05:41 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-12-09 21:05:41 +0100wroathe(~wroathe@user/wroathe)
2021-12-09 21:05:49 +0100 <WilliamJ> monochrom as I see above, that would be a list of strings
2021-12-09 21:05:51 +0100 <monochrom> False dichotomy.
2021-12-09 21:05:51 +0100 <aplainzetakind> So that's your problem. You are attmeting something that doesn't make sense.
2021-12-09 21:05:56 +0100 <geekosaur> zero, both. the data structure is identical, only the operations are striuct/lazy
2021-12-09 21:06:00 +0100 <aplainzetakind> attempting*
2021-12-09 21:06:16 +0100 <WilliamJ> Okay, I am seeing where it is coming from now
2021-12-09 21:06:20 +0100 <monochrom> Data.Set is strict in BST skeleton, lazy in value.
2021-12-09 21:06:28 +0100 <boxscape> hackage says "A Set is strict in its elements."
2021-12-09 21:06:33 +0100 <monochrom> err, wait, no, not entirely lazy in value.
2021-12-09 21:06:35 +0100 <int-e> monochrom: there's no values, only keys
2021-12-09 21:06:38 +0100 <zero> ah. i get it. thanks
2021-12-09 21:06:56 +0100 <zero> because order
2021-12-09 21:06:57 +0100 <aplainzetakind> WilliamJ: You want to prepend i spaces to each chunk of '*', where are they?.
2021-12-09 21:07:08 +0100 <monochrom> It is somewhat strict in values to the point of resolving x<=y questions.
2021-12-09 21:07:18 +0100 <geekosaur> and it makes no sense to have a lazy Set because (a) no values to be lazy (b) spine has to be strict due to ordering and balancing
2021-12-09 21:07:18 +0100juhp(~juhp@128.106.188.82)
2021-12-09 21:07:19 +0100 <int-e> Oh I guess if your keys are lists they're only evaluated as far as necessary to compare all the keys
2021-12-09 21:07:31 +0100 <WilliamJ> the chunk of '*' are in a list
2021-12-09 21:07:44 +0100 <int-e> So yeah there's some laziness in that, though I'd attribute that to Ord, not to the Set
2021-12-09 21:07:54 +0100jinsun__(~quassel@user/jinsun)
2021-12-09 21:07:56 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-12-09 21:08:19 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net)
2021-12-09 21:08:22 +0100 <aplainzetakind> > replicate 5 '*'
2021-12-09 21:08:24 +0100 <lambdabot> "*****"
2021-12-09 21:08:25 +0100 <monochrom> Well, Map.Strict is only strict in values to the extent of WHNF anyway.
2021-12-09 21:08:37 +0100 <aplainzetakind> Such things are what you want to indent right?
2021-12-09 21:08:49 +0100 <WilliamJ> correct
2021-12-09 21:08:56 +0100 <monochrom> False dichotomies are false.
2021-12-09 21:09:00 +0100 <aplainzetakind> Then prepend your spaces to those expressions.
2021-12-09 21:09:16 +0100 <monochrom> The world is more interesting than "lazy vs strict".
2021-12-09 21:09:20 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 21:09:29 +0100 <monochrom> And more interesting than "functions vs not functions"
2021-12-09 21:09:35 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 21:09:43 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 21:09:47 +0100 <WilliamJ> Ok, I shall give it a try
2021-12-09 21:09:58 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 21:10:05 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 21:10:08 +0100 <monochrom> I am monochrom but even my avatar is a 256-level gray scale, not just two blobs of white and black.
2021-12-09 21:10:13 +0100vgtw(~vgtw@c-2359205c.07-348-756d651.bbcust.telenor.se) (Ping timeout: 240 seconds)
2021-12-09 21:10:13 +0100swistak(~swistak@185.21.216.141) (Ping timeout: 240 seconds)
2021-12-09 21:10:20 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 21:10:26 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 21:10:38 +0100vgtw(~vgtw@c-2359205c.07-348-756d651.bbcust.telenor.se)
2021-12-09 21:10:41 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 21:10:48 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 21:11:01 +0100jinsun(~quassel@user/jinsun) (Ping timeout: 240 seconds)
2021-12-09 21:11:40 +0100 <johnw> not 50-level gray scale?
2021-12-09 21:11:44 +0100 <WilliamJ> I just tried to prepend using : instead of ++ but I am having no luck, am i doing something wrong?
2021-12-09 21:11:45 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 268 seconds)
2021-12-09 21:11:58 +0100 <aplainzetakind> Yes.
2021-12-09 21:12:04 +0100 <monochrom> Haha but I made my avatar long before 50 Shades of Grey.
2021-12-09 21:12:08 +0100 <aplainzetakind> Why did you feel the need to use (:)?
2021-12-09 21:12:27 +0100bonz060(~quassel@2001:bc8:47a4:a23::1)
2021-12-09 21:12:31 +0100 <aplainzetakind> :t replicate 3 ' '
2021-12-09 21:12:32 +0100 <lambdabot> [Char]
2021-12-09 21:12:37 +0100 <aplainzetakind> :t replicate 3 '*'
2021-12-09 21:12:38 +0100 <lambdabot> [Char]
2021-12-09 21:12:49 +0100 <WilliamJ> Because when I have done other exercises, I have used : to add stuff onto the end of stuff hence I thought it would be the same for this
2021-12-09 21:12:53 +0100 <WilliamJ> rectangle i m n = unlines (replicate i ' ' : replicate m (replicate n '*')) is what I tried
2021-12-09 21:13:07 +0100swistak(~swistak@185.21.216.141)
2021-12-09 21:13:14 +0100 <EvanR> : adds 1 stuff to the beginning
2021-12-09 21:13:23 +0100 <int-e> well at least it type-checks
2021-12-09 21:13:27 +0100 <aplainzetakind> I mean that typechecks.
2021-12-09 21:13:29 +0100 <aplainzetakind> At least.
2021-12-09 21:13:32 +0100 <monochrom> The vagueness of "add stuff to stuff" is why you are failing.
2021-12-09 21:13:34 +0100 <WilliamJ> it runs, but doesnt how I expect it to
2021-12-09 21:13:35 +0100 <aplainzetakind> But does not do what you want.
2021-12-09 21:13:49 +0100 <int-e> you'll get one line full of spaces
2021-12-09 21:14:01 +0100 <WilliamJ> yeah
2021-12-09 21:14:01 +0100 <aplainzetakind> Because you are not putting spaces before the asterisks.
2021-12-09 21:14:04 +0100 <int-e> followed by a non-idented rectangle
2021-12-09 21:14:08 +0100 <aplainzetakind> But somewhere else.
2021-12-09 21:14:22 +0100 <int-e> you need to modify every single line to achieve indentation
2021-12-09 21:14:30 +0100 <aplainzetakind> replicate 3 ' ' ++ replicate 5 '*'
2021-12-09 21:14:35 +0100 <aplainzetakind> > replicate 3 ' ' ++ replicate 5 '*'
2021-12-09 21:14:37 +0100 <lambdabot> " *****"
2021-12-09 21:14:43 +0100 <aplainzetakind> These are your lines.
2021-12-09 21:14:55 +0100 <WilliamJ> Yes that is what I want to acheive
2021-12-09 21:14:58 +0100 <WilliamJ> achieve*
2021-12-09 21:15:02 +0100 <aplainzetakind> Then please achive it.
2021-12-09 21:15:10 +0100 <WilliamJ> I am trying
2021-12-09 21:17:54 +0100 <WilliamJ> ok I got it working
2021-12-09 21:18:00 +0100 <WilliamJ> rectangle i m n = unlines (replicate m (replicate i ' ' ++ (replicate n '*')))
2021-12-09 21:18:00 +0100 <aplainzetakind> Great.
2021-12-09 21:18:14 +0100 <aplainzetakind> The innermost parens are unnecessary.
2021-12-09 21:18:16 +0100 <WilliamJ> give me the output I want
2021-12-09 21:18:33 +0100 <WilliamJ> Ok
2021-12-09 21:18:35 +0100 <aplainzetakind> function application has highest precedence.
2021-12-09 21:19:05 +0100 <WilliamJ> I understand, I had them there from a previous attempt.
2021-12-09 21:19:12 +0100 <aplainzetakind> Now you need to call this with appropriate parameters an appropriate number of times as dictated by the parameters of your main function.
2021-12-09 21:19:46 +0100nebu(~user@user/wavion) (Ping timeout: 268 seconds)
2021-12-09 21:19:57 +0100 <aplainzetakind> And "call" can be misleading. Let's say evaluate.
2021-12-09 21:20:11 +0100 <WilliamJ> yes, so the main function lets say is called rectangles since it will be a plural
2021-12-09 21:20:43 +0100 <WilliamJ> So for that, it will be similar but now we need to include the steps
2021-12-09 21:21:02 +0100 <aplainzetakind> Well, it may not be so similar.
2021-12-09 21:21:20 +0100 <aplainzetakind> So what were your parameters again?
2021-12-09 21:21:30 +0100 <WilliamJ> Width, Height/length and steps
2021-12-09 21:21:43 +0100 <WilliamJ> So the type definition would be the same as theyre all integers
2021-12-09 21:21:56 +0100averell(~averell@user/averell)
2021-12-09 21:22:30 +0100 <monochrom> I would be surprised if normally the caller of a function is similar to the internals of the called function.
2021-12-09 21:22:30 +0100 <aplainzetakind> rectangles a b c -> a is height, b is starting width, indentation starts with 0 and both indentation and with increase by c for each successive rectangle?
2021-12-09 21:22:47 +0100 <WilliamJ> Yes, that is it
2021-12-09 21:23:10 +0100 <WilliamJ> Hence it would be rectangles :: Int -> Int -> Int -> String?
2021-12-09 21:23:16 +0100 <aplainzetakind> So first produce your sequence of indentations and widths.
2021-12-09 21:23:20 +0100 <aplainzetakind> That is correct.
2021-12-09 21:23:38 +0100 <aplainzetakind> Are you familiar with `let` bindings?
2021-12-09 21:23:58 +0100 <WilliamJ> We have been shown where bindings but not let I dont think
2021-12-09 21:24:10 +0100phma(~phma@host-67-44-208-5.hnremote.net) (Read error: Connection reset by peer)
2021-12-09 21:24:11 +0100 <aplainzetakind> OK, use where.
2021-12-09 21:24:13 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-12-09 21:24:45 +0100alx741(~alx741@157.100.93.160) (Ping timeout: 265 seconds)
2021-12-09 21:24:45 +0100 <aplainzetakind> Write rectangles h w s = undefined; where ...
2021-12-09 21:25:01 +0100neurocyte0132889(~neurocyte@user/neurocyte) (Quit: The Lounge - https://thelounge.chat)
2021-12-09 21:25:07 +0100phma(~phma@host-67-44-209-94.hnremote.net)
2021-12-09 21:25:08 +0100 <aplainzetakind> And in that where clause create useful building blocks.
2021-12-09 21:25:30 +0100 <aplainzetakind> I think you need the lists of successive indentations and successive widths.
2021-12-09 21:25:31 +0100 <WilliamJ> where
2021-12-09 21:25:32 +0100 <WilliamJ>   h=0 or w = 0 or s = 0?
2021-12-09 21:26:02 +0100 <WilliamJ> or is the undefinied a place holder for the sequence?
2021-12-09 21:26:15 +0100 <aplainzetakind> No, such things would shadow the actual parameters.
2021-12-09 21:26:24 +0100 <aplainzetakind> You will create new names.
2021-12-09 21:26:43 +0100 <aplainzetakind> Or would they just be errors outright, I'm not sure actually.
2021-12-09 21:27:09 +0100 <WilliamJ> I think it would just output lines unless s = 0
2021-12-09 21:27:27 +0100 <WilliamJ> in that case, nothing would be output
2021-12-09 21:27:31 +0100 <aplainzetakind> Structurally, you want something like the following: addOneToDouble x = y + 1; where y = 2 * x.
2021-12-09 21:27:33 +0100jinsun__jinsun
2021-12-09 21:27:55 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net)
2021-12-09 21:27:55 +0100wroathe(~wroathe@c-68-54-25-135.hsd1.mn.comcast.net) (Changing host)
2021-12-09 21:27:55 +0100wroathe(~wroathe@user/wroathe)
2021-12-09 21:28:10 +0100 <WilliamJ> ok so, sorry if this is a bit annoying, but why would be use a where binding within this function?
2021-12-09 21:29:05 +0100neurocyte0132889(~neurocyte@45.93.108.168)
2021-12-09 21:29:05 +0100neurocyte0132889(~neurocyte@45.93.108.168) (Changing host)
2021-12-09 21:29:05 +0100neurocyte0132889(~neurocyte@user/neurocyte)
2021-12-09 21:29:11 +0100Flonk7(~Flonk@vps-zap441517-1.zap-srv.com)
2021-12-09 21:29:19 +0100 <aplainzetakind> In the where clause, define indentSeq :: [Int] and widthSeq :: [Int] in an appropriate manner. After that you will replace undefined with your final expression which will use those as building blocks.
2021-12-09 21:30:13 +0100Flonk(~Flonk@vps-zap441517-1.zap-srv.com) (Ping timeout: 252 seconds)
2021-12-09 21:30:13 +0100Flonk7Flonk
2021-12-09 21:30:20 +0100 <aplainzetakind> It's not strictly necessary, just makes things cleaner and more structured. It's better practice to write many small and easily readible things then combine them in again small and easily readible things, as opposed to writing a huge expression.
2021-12-09 21:31:07 +0100 <WilliamJ> ok so, for indentSeq, we should have it as 0 then after each rectangle, we add the value of w to it
2021-12-09 21:31:29 +0100 <aplainzetakind> You can write addOneToDouble = 2 * x + 1, and in that toy example of course there's no gain in readibility in using where.
2021-12-09 21:31:31 +0100 <aplainzetakind> Yes.
2021-12-09 21:32:14 +0100 <WilliamJ> Ok so, I'm going to pastebin to show you what I currently have if that is ok
2021-12-09 21:32:20 +0100 <aplainzetakind> Sure.
2021-12-09 21:32:29 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 265 seconds)
2021-12-09 21:32:42 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 21:32:48 +0100 <WilliamJ> https://paste.tomsmeding.com/V9aT8LHO
2021-12-09 21:33:23 +0100 <WilliamJ> so for Indentseq, I should do indentseq = 0 + w correct? Or have I missed something?
2021-12-09 21:33:51 +0100 <aplainzetakind> That would give you a single number. You want a List.
2021-12-09 21:34:15 +0100 <aplainzetakind> > [1..10]
2021-12-09 21:34:17 +0100 <lambdabot> [1,2,3,4,5,6,7,8,9,10]
2021-12-09 21:34:24 +0100 <aplainzetakind> ^ You are familiar with this notation?
2021-12-09 21:34:37 +0100 <WilliamJ> Yes, I have used that a few times when we practiced list comprehensions
2021-12-09 21:34:52 +0100 <aplainzetakind> > [1,7..100]
2021-12-09 21:34:53 +0100 <lambdabot> [1,7,13,19,25,31,37,43,49,55,61,67,73,79,85,91,97]
2021-12-09 21:34:57 +0100 <aplainzetakind> ^ This too?
2021-12-09 21:35:12 +0100 <WilliamJ> mhm, not that one
2021-12-09 21:35:22 +0100 <aplainzetakind> Well, no you know.
2021-12-09 21:35:29 +0100 <aplainzetakind> now you know*
2021-12-09 21:35:37 +0100 <WilliamJ> so does it take the difference of the first 2 numbers and add it to every number afterwards
2021-12-09 21:35:56 +0100 <aplainzetakind> Yes.
2021-12-09 21:35:57 +0100 <geekosaur> yes
2021-12-09 21:35:58 +0100Kevin578(~Kevin578@pool-96-237-112-198.bstnma.fios.verizon.net) (Ping timeout: 256 seconds)
2021-12-09 21:36:05 +0100 <geekosaur> it's also called enumFromThenTo
2021-12-09 21:36:28 +0100 <WilliamJ> so for indentseq, would we do something online the lines of [0..w+w]?
2021-12-09 21:36:37 +0100 <WilliamJ> along*
2021-12-09 21:36:52 +0100Kevin578(~Kevin578@pool-96-237-112-198.bstnma.fios.verizon.net)
2021-12-09 21:37:06 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 256 seconds)
2021-12-09 21:37:06 +0100curiousgay(~curiousga@77-120-141-90.kha.volia.net) (Ping timeout: 256 seconds)
2021-12-09 21:37:15 +0100 <aplainzetakind> Try it in the repl with concrete numbers to see what gives you what you want.
2021-12-09 21:37:30 +0100 <monochrom> You can try [0 .. 4+4] and see what you get.
2021-12-09 21:37:50 +0100 <WilliamJ> ok, that is not what i want that gives me numbers up 8
2021-12-09 21:37:57 +0100 <WilliamJ> I see why it is doing it
2021-12-09 21:37:59 +0100k60``(~user@static.100.218.46.78.clients.your-server.de)
2021-12-09 21:38:44 +0100 <aplainzetakind> Does the indentation increase by the width or the step parameter?
2021-12-09 21:39:37 +0100 <WilliamJ> width, so for example if we had rectangles 3 2 3, the indentation would be 0,3,6
2021-12-09 21:39:52 +0100 <WilliamJ> due to that being the width of the last rectangle
2021-12-09 21:40:19 +0100 <aplainzetakind> By the way, you don't need to specify an end. For example [0,2..] is the infinite list of all even positive integers.
2021-12-09 21:40:40 +0100 <WilliamJ> sounds good
2021-12-09 21:40:54 +0100 <aplainzetakind> I thought we said both the width and the indentation increase by the step parameter.
2021-12-09 21:41:23 +0100 <monochrom> The step parameter is how many rectangles to make.
2021-12-09 21:41:28 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 21:41:31 +0100 <WilliamJ> step parameter is how many rectangles there is, did I not say before? Sorry if I didnt
2021-12-09 21:42:57 +0100 <monochrom> I am surprised the teacher didn't word it as "count" or "numRects" or "n".
2021-12-09 21:43:05 +0100 <aplainzetakind> so for `rectangles 2 5 7`, there are 7 rectangles, each of height 2, with widths 5,10,15, ... and indented such that they touch at the corners?
2021-12-09 21:43:24 +0100 <WilliamJ> yeah that is correct
2021-12-09 21:43:33 +0100 <WilliamJ> monochrom i'll admit, it did confuse me at the start too
2021-12-09 21:43:38 +0100stevenxl(~stevenxl@174.128.182.199) (Quit: leaving)
2021-12-09 21:44:06 +0100 <aplainzetakind> So indentation depends on width. First write widthseq then.
2021-12-09 21:44:28 +0100 <int-e> :t scanl
2021-12-09 21:44:29 +0100 <lambdabot> (b -> a -> b) -> b -> [a] -> [b]
2021-12-09 21:44:32 +0100 <WilliamJ> so for width, we will start with w
2021-12-09 21:44:32 +0100 <monochrom> If you look at BASIC or FORTRAN "for i = 1 to 100 step 3" no one would ever guess "it means 3 iterations".
2021-12-09 21:45:03 +0100neurocyte0132889(~neurocyte@user/neurocyte) (Ping timeout: 265 seconds)
2021-12-09 21:45:06 +0100 <int-e> monochrom: hmm, why not though
2021-12-09 21:45:07 +0100 <aplainzetakind> WilliamJ: And the next one in line is?
2021-12-09 21:45:20 +0100 <WilliamJ> w+w
2021-12-09 21:45:32 +0100 <aplainzetakind> Yes.
2021-12-09 21:45:45 +0100 <aplainzetakind> Are you familiar with take?
2021-12-09 21:45:46 +0100mrkajetanp(~mrkajetan@2a01:4b00:ea36:6c00:7994:941c:3f5d:2b88) (Ping timeout: 245 seconds)
2021-12-09 21:45:48 +0100 <aplainzetakind> :t take
2021-12-09 21:45:49 +0100 <lambdabot> Int -> [a] -> [a]
2021-12-09 21:45:50 +0100 <WilliamJ> but as I saw before, w+w inside the list doesnt add it
2021-12-09 21:45:56 +0100 <WilliamJ> Yes, we have used it
2021-12-09 21:46:03 +0100 <aplainzetakind> You put it in the wrong spot.
2021-12-09 21:46:05 +0100Benzi-Junior(~BenziJuni@88-149-66-61.du.xdsl.is) (Remote host closed the connection)
2021-12-09 21:46:08 +0100 <WilliamJ> oh
2021-12-09 21:46:12 +0100 <aplainzetakind> > [1..7]
2021-12-09 21:46:14 +0100 <lambdabot> [1,2,3,4,5,6,7]
2021-12-09 21:46:21 +0100Benzi-Junior(~BenziJuni@88-149-66-61.du.xdsl.is)
2021-12-09 21:46:21 +0100 <aplainzetakind> > [1,7..]
2021-12-09 21:46:22 +0100 <lambdabot> [1,7,13,19,25,31,37,43,49,55,61,67,73,79,85,91,97,103,109,115,121,127,133,13...
2021-12-09 21:46:26 +0100mrkajetanp(~mrkajetan@2a01:4b00:ea36:6c00:7994:941c:3f5d:2b88)
2021-12-09 21:46:29 +0100 <aplainzetakind> (infinite list)
2021-12-09 21:46:36 +0100mrmonday(~robert@what.i.hope.is.not.a.tabernaevagant.es) (Read error: Connection reset by peer)
2021-12-09 21:46:39 +0100 <WilliamJ> so for take, would take the last index and add w
2021-12-09 21:46:55 +0100 <aplainzetakind> Don't jump to take for now.
2021-12-09 21:46:55 +0100quantum(~quantum@user/quantum/x-8556232) (Ping timeout: 268 seconds)
2021-12-09 21:46:55 +0100utk(~utk@2001:470:69fc:105::1:2fe0) (Ping timeout: 268 seconds)
2021-12-09 21:46:55 +0100jophish(~jophish@2001:470:69fc:105::670) (Ping timeout: 268 seconds)
2021-12-09 21:46:55 +0100Deide(~deide@user/deide) (Ping timeout: 268 seconds)
2021-12-09 21:46:59 +0100 <WilliamJ> ok
2021-12-09 21:47:25 +0100ServerStatsDisco(~serversta@2001:470:69fc:105::1a) (Ping timeout: 240 seconds)
2021-12-09 21:47:26 +0100carmysilna(~brightly-@2001:470:69fc:105::2190) (Ping timeout: 245 seconds)
2021-12-09 21:47:26 +0100justosophy[m](~justosoph@2001:470:69fc:105::572f) (Ping timeout: 245 seconds)
2021-12-09 21:47:26 +0100SawyerBergeron[m(~sawyerber@2001:470:69fc:105::3036) (Ping timeout: 245 seconds)
2021-12-09 21:47:32 +0100acco[m](~accotedom@2001:470:69fc:105::1:3236) (Ping timeout: 240 seconds)
2021-12-09 21:47:32 +0100unclechu(~unclechu@2001:470:69fc:105::354) (Ping timeout: 240 seconds)
2021-12-09 21:47:35 +0100fcortesi(~fcortesi@2001:470:69fc:105::f3a9) (Ping timeout: 250 seconds)
2021-12-09 21:47:35 +0100aidy(~aidy@2001:470:69fc:105::c7b4) (Ping timeout: 250 seconds)
2021-12-09 21:47:36 +0100 <aplainzetakind> subtask: create an infinite list of multiples of w: [w, 2*w, 3*w, etc.]
2021-12-09 21:47:38 +0100jinsun_(~jinsun@user/jinsun) (Ping timeout: 252 seconds)
2021-12-09 21:47:45 +0100mrmonday(~robert@what.i.hope.is.not.a.tabernaevagant.es)
2021-12-09 21:47:46 +0100ilkecan[m](~ilkecanma@2001:470:69fc:105::1:79b) (Ping timeout: 260 seconds)
2021-12-09 21:47:46 +0100thomasjm[m](~thomasjmm@2001:470:69fc:105::c6d9) (Ping timeout: 260 seconds)
2021-12-09 21:47:46 +0100craige[m](~craigemcw@2001:470:69fc:105::35f1) (Ping timeout: 260 seconds)
2021-12-09 21:47:46 +0100fendor[m](~fendormat@2001:470:69fc:105::fcbd) (Ping timeout: 260 seconds)
2021-12-09 21:47:46 +0100Topik[m](~topikmatr@2001:470:69fc:105::a082) (Ping timeout: 260 seconds)
2021-12-09 21:47:48 +0100TomasJakl[m](~jaklttchn@2001:470:69fc:105::a42) (Ping timeout: 250 seconds)
2021-12-09 21:47:54 +0100 <raehik> Every time I generate Hackage docs to upload, it ends up not linking types like Functor, Eq correctly to their definitions. I'm invoking the v2 cabal command Hackage tells me to. Any potential pointers?
2021-12-09 21:48:02 +0100siraben(~siraben@user/siraben) (Ping timeout: 240 seconds)
2021-12-09 21:48:02 +0100inkbottle[m](~inkbottle@2001:470:69fc:105::2ff5) (Ping timeout: 240 seconds)
2021-12-09 21:48:02 +0100benjamin[m]12(~benjaminm@2001:470:69fc:105::1:3f2f) (Ping timeout: 240 seconds)
2021-12-09 21:48:02 +0100denbrahe[m](~denbrahem@2001:470:69fc:105::19c0) (Ping timeout: 240 seconds)
2021-12-09 21:48:02 +0100JoelMcCracken[m](~joelmccra@2001:470:69fc:105::8405) (Ping timeout: 240 seconds)
2021-12-09 21:48:02 +0100 <raehik> example https://hackage.haskell.org/package/fortran-src-0.7.0/docs/Language-Fortran-AST.html
2021-12-09 21:48:13 +0100bb010g(~bb010g@2001:470:69fc:105::9a5) (Ping timeout: 240 seconds)
2021-12-09 21:48:13 +0100thedward[m](~thedwardm@2001:470:69fc:105::f79) (Ping timeout: 250 seconds)
2021-12-09 21:48:14 +0100smichel17[m](~smichel17@2001:470:69fc:105::2d32) (Ping timeout: 250 seconds)
2021-12-09 21:48:14 +0100boxscape(~boxscape@user/boxscape) (Ping timeout: 260 seconds)
2021-12-09 21:48:16 +0100ppseafield[m](~elementpp@2001:470:69fc:105::1:250a) (Ping timeout: 245 seconds)
2021-12-09 21:48:27 +0100vaibhavsagar[m](~vaibhavsa@2001:470:69fc:105::ffe) (Ping timeout: 250 seconds)
2021-12-09 21:48:27 +0100fgaz(~fgaz@2001:470:69fc:105::842) (Ping timeout: 250 seconds)
2021-12-09 21:48:27 +0100Ollie[m](~ollieocha@2001:470:69fc:105::41a5) (Ping timeout: 250 seconds)
2021-12-09 21:48:27 +0100Movedtosridoneem(~sridmatri@2001:470:69fc:105::1c2) (Ping timeout: 250 seconds)
2021-12-09 21:48:34 +0100 <WilliamJ> ok i'll give that a go now and report back in a minute or 2 if i figure out how to get it to work
2021-12-09 21:48:42 +0100fsckskye[m](~kmatrixth@2001:470:69fc:105::1:3b2f) (Ping timeout: 260 seconds)
2021-12-09 21:48:42 +0100the-coot[m](~the-cootm@2001:470:69fc:105::95f) (Ping timeout: 260 seconds)
2021-12-09 21:48:42 +0100hughjfchen[m](~hughjfche@2001:470:69fc:105::c29d) (Ping timeout: 260 seconds)
2021-12-09 21:48:44 +0100jchia[m](~jchiamatr@2001:470:69fc:105::c50b) (Ping timeout: 252 seconds)
2021-12-09 21:49:05 +0100InternetManaging(~imjmatrix@2001:470:69fc:105::1:2ea5) (Ping timeout: 250 seconds)
2021-12-09 21:49:06 +0100shiraeeshi[m](~shiraeesh@2001:470:69fc:105::1:77) (Ping timeout: 245 seconds)
2021-12-09 21:49:06 +0100james[m]12(~jamesnina@2001:470:69fc:105::1:4203) (Ping timeout: 245 seconds)
2021-12-09 21:49:06 +0100surgeon[m](~surge9nma@2001:470:69fc:105::f585) (Ping timeout: 245 seconds)
2021-12-09 21:49:06 +0100octeep[m](~octeepoct@2001:470:69fc:105::1:3dbf) (Ping timeout: 245 seconds)
2021-12-09 21:49:17 +0100unrooted(~unrooted@2001:470:69fc:105::a4a) (Ping timeout: 252 seconds)
2021-12-09 21:49:17 +0100hsiktas[m](~hsiktasma@2001:470:69fc:105::30d4) (Ping timeout: 252 seconds)
2021-12-09 21:49:19 +0100schuelermine[m](~schuelerm@user/schuelermine) (Ping timeout: 250 seconds)
2021-12-09 21:49:19 +0100peddie(~peddie@2001:470:69fc:105::25d) (Ping timeout: 250 seconds)
2021-12-09 21:49:31 +0100Christoph[m](~hpotsirhc@2001:470:69fc:105::2ff8) (Ping timeout: 245 seconds)
2021-12-09 21:49:31 +0100asdofindia-m(~akshaymat@2001:470:69fc:105::831) (Ping timeout: 245 seconds)
2021-12-09 21:49:31 +0100lambdandy[m](~lambdandy@2001:470:69fc:105::1:3045) (Ping timeout: 250 seconds)
2021-12-09 21:49:31 +0100oak-(~oakuniver@2001:470:69fc:105::fcd) (Ping timeout: 250 seconds)
2021-12-09 21:49:31 +0100Artem[m](~artemtype@2001:470:69fc:105::75b) (Ping timeout: 250 seconds)
2021-12-09 21:49:32 +0100xddq[m](~xddqmatri@2001:470:69fc:105::bfd8) (Ping timeout: 240 seconds)
2021-12-09 21:49:32 +0100soft(~soft@2001:470:69fc:105::c75) (Ping timeout: 240 seconds)
2021-12-09 21:49:32 +0100DemiMarieObenour(~alwayscur@2001:470:69fc:105::4886) (Ping timeout: 240 seconds)
2021-12-09 21:49:32 +0100zfnmxt(~zfnmxtzfn@2001:470:69fc:105::2b32) (Ping timeout: 240 seconds)
2021-12-09 21:49:32 +0100bitonic(~bitonic@2001:470:69fc:105::1812) (Ping timeout: 240 seconds)
2021-12-09 21:49:38 +0100puffnfresh[m](~puffnfres@2001:470:69fc:105::1:22da) (Ping timeout: 260 seconds)
2021-12-09 21:49:38 +0100amesgen[m](~amesgenm]@2001:470:69fc:105::82b) (Ping timeout: 260 seconds)
2021-12-09 21:49:38 +0100tomku[m](~tomkumozi@2001:470:69fc:105::1:2fcb) (Ping timeout: 260 seconds)
2021-12-09 21:49:45 +0100alex[m]121(~alexchete@2001:470:69fc:105::1:1001) (Ping timeout: 250 seconds)
2021-12-09 21:49:45 +0100TomWesterhout[m](~twesterho@2001:470:69fc:105::1:2918) (Ping timeout: 250 seconds)
2021-12-09 21:49:45 +0100cdsmith(~cdsmithma@2001:470:69fc:105::284) (Ping timeout: 250 seconds)
2021-12-09 21:49:45 +0100MatrixTravelerbo(~voyagert2@2001:470:69fc:105::22) (Ping timeout: 250 seconds)
2021-12-09 21:49:45 +0100chizil[m](~chizilmat@2001:470:69fc:105::1:34ab) (Ping timeout: 250 seconds)
2021-12-09 21:49:45 +0100jneira[m](~jneiramat@2001:470:69fc:105::d729) (Ping timeout: 250 seconds)
2021-12-09 21:49:45 +0100zwro[m](~zwromatri@2001:470:69fc:105::1d4) (Ping timeout: 250 seconds)
2021-12-09 21:49:50 +0100 <WilliamJ> Ok, it isnt with w's, but I found a way to multiply each index by 2 but not going up in 1
2021-12-09 21:49:50 +0100moats(~oats@user/oats) (Ping timeout: 252 seconds)
2021-12-09 21:49:50 +0100 <aplainzetakind> WilliamJ: If you write something like [1..] in the repl it will flood with infinite numbers, so do things like `take 20 [1..]` so that you can see what's going on.
2021-12-09 21:49:53 +0100reza[m](~rezaphone@2001:470:69fc:105::3eda) (Ping timeout: 265 seconds)
2021-12-09 21:49:57 +0100Magnus[m](~magthetch@2001:470:69fc:105::d1a7) (Ping timeout: 250 seconds)
2021-12-09 21:50:02 +0100sm(~sm@plaintextaccounting/sm) (Ping timeout: 240 seconds)
2021-12-09 21:50:02 +0100Tisoxin(~ikosit@user/ikosit) (Ping timeout: 240 seconds)
2021-12-09 21:50:02 +0100psydroid(~psydroid@user/psydroid) (Ping timeout: 240 seconds)
2021-12-09 21:50:06 +0100ongy[m](~ongymatri@2001:470:69fc:105::5018) (Ping timeout: 260 seconds)
2021-12-09 21:50:06 +0100kadoban(~kadoban@user/kadoban) (Ping timeout: 260 seconds)
2021-12-09 21:50:06 +0100maerwald[m](~maerwaldm@2001:470:69fc:105::1ee) (Ping timeout: 260 seconds)
2021-12-09 21:50:06 +0100ManofLetters[m](~manoflett@2001:470:69fc:105::3be) (Ping timeout: 260 seconds)
2021-12-09 21:50:17 +0100 <aplainzetakind> WilliamJ: What do you mean? Can you paste the expression here?
2021-12-09 21:50:22 +0100aveltras[m](~aveltrasm@2001:470:69fc:105::3ef9) (Ping timeout: 265 seconds)
2021-12-09 21:50:27 +0100 <WilliamJ> map (*2) [1..5]
2021-12-09 21:50:33 +0100 <WilliamJ> gives me [2,4,6,8,10]
2021-12-09 21:50:37 +0100iammrinal0[m](~iammrinal@2001:470:69fc:105::1:2248) (Ping timeout: 268 seconds)
2021-12-09 21:50:37 +0100std_mutex[m](~stdmutexm@2001:470:69fc:105::1:4534) (Ping timeout: 268 seconds)
2021-12-09 21:50:37 +0100AlainJourez[m](~sherekahn@2001:470:69fc:105::1:4a71) (Ping timeout: 250 seconds)
2021-12-09 21:50:38 +0100maralorn(~maralorn@2001:470:69fc:105::251) (Ping timeout: 268 seconds)
2021-12-09 21:50:38 +0100rednaZ[m](~r3dnazmat@2001:470:69fc:105::ba70) (Ping timeout: 268 seconds)
2021-12-09 21:50:38 +0100ericson2314(~ericson23@2001:470:69fc:105::70c) (Ping timeout: 268 seconds)
2021-12-09 21:50:38 +0100wildsebastian(~wildsebas@2001:470:69fc:105::1:14b1) (Ping timeout: 268 seconds)
2021-12-09 21:50:38 +0100meatfeather[m](~meatfeath@2001:470:69fc:105::1:3311) (Ping timeout: 268 seconds)
2021-12-09 21:50:38 +0100ocramz[m](~ocramzmat@2001:470:69fc:105::1:35b0) (Ping timeout: 268 seconds)
2021-12-09 21:50:38 +0100wysteriary[m](~wysteriar@2001:470:69fc:105::a42e) (Ping timeout: 268 seconds)
2021-12-09 21:50:38 +0100marinelli[m](~marinelli@2001:470:69fc:105::2d8) (Ping timeout: 268 seconds)
2021-12-09 21:50:40 +0100 <aplainzetakind> That's also good.
2021-12-09 21:50:50 +0100 <aplainzetakind> So you can replace 2 by ...
2021-12-09 21:51:03 +0100 <WilliamJ> but like you said, w: [w, 2*w, 3*w, etc.] I am not sure how to make it go up each time
2021-12-09 21:51:20 +0100 <aplainzetakind> What you did does go up each time, just by 2 and not w.
2021-12-09 21:51:31 +0100 <WilliamJ> wait, i sde
2021-12-09 21:51:32 +0100 <WilliamJ> see
2021-12-09 21:51:38 +0100 <WilliamJ> so if i replace 2 with w
2021-12-09 21:51:51 +0100jkachmar(~jkachmar@2001:470:69fc:105::c72d) (Ping timeout: 268 seconds)
2021-12-09 21:51:51 +0100RosarioPulella[m(~rosariopu@2001:470:69fc:105::a57) (Ping timeout: 268 seconds)
2021-12-09 21:51:51 +0100jmcantrell(~jmcantrel@user/jmcantrell) (Ping timeout: 268 seconds)
2021-12-09 21:51:51 +0100Arathorn(~arathorn@2001:470:69fc:105::1f) (Ping timeout: 268 seconds)
2021-12-09 21:51:51 +0100alexfmpe[m](~alexfmpem@2001:470:69fc:105::38ba) (Ping timeout: 268 seconds)
2021-12-09 21:52:14 +0100WilliamJ17(~WilliamJ@wireless-student-pt10-182-232.lut.ac.uk)
2021-12-09 21:52:20 +0100acidjnk_new(~acidjnk@pd9e0bdc0.dip0.t-ipconnect.de)
2021-12-09 21:52:22 +0100 <WilliamJ17> I got disconnected sorry
2021-12-09 21:52:23 +0100pfurla(~pfurla@2804:14d:5c81:4104:25b5:2708:65a9:4e7d)
2021-12-09 21:52:24 +0100 <aplainzetakind> Also you want s numbers and not 5.
2021-12-09 21:52:27 +0100 <WilliamJ17> yes
2021-12-09 21:52:28 +0100Orbstheorem(~orbstheor@2001:470:69fc:105::a56) (Ping timeout: 268 seconds)
2021-12-09 21:52:44 +0100 <WilliamJ17> I was thinking map (*w) [1..s]
2021-12-09 21:52:52 +0100pavonia(~user@user/siracusa)
2021-12-09 21:52:58 +0100 <aplainzetakind> That is correct.
2021-12-09 21:53:20 +0100 <WilliamJ17> widthseq = map (*w) [1..s] is what I have then
2021-12-09 21:53:33 +0100 <aplainzetakind> Now write out the first few terms of indentseq
2021-12-09 21:53:43 +0100 <aplainzetakind> Yes that's good.
2021-12-09 21:53:55 +0100 <WilliamJ17> so is it the same, but starts at 0 and is s-1?
2021-12-09 21:54:02 +0100son0p(~ff@181.136.122.143) (Remote host closed the connection)
2021-12-09 21:54:03 +0100 <aplainzetakind> Yes.
2021-12-09 21:54:43 +0100 <WilliamJ17> indentseq :: [Int]
2021-12-09 21:54:43 +0100 <WilliamJ17>  indentseq = map (*w) [1..s-1]
2021-12-09 21:54:44 +0100 <WilliamJ17>  widthseq :: [Int]
2021-12-09 21:54:44 +0100 <WilliamJ17>  widthseq = map (*w) [1..s]
2021-12-09 21:54:45 +0100 <WilliamJ17> is what I have
2021-12-09 21:54:56 +0100 <WilliamJ17> should be 0 not 1 in indentseq
2021-12-09 21:55:23 +0100 <aplainzetakind> Now you need a way to call your other rectangle function on these somehow.
2021-12-09 21:55:29 +0100 <aplainzetakind> :t zipWith
2021-12-09 21:55:30 +0100 <lambdabot> (a -> b -> c) -> [a] -> [b] -> [c]
2021-12-09 21:55:43 +0100std_mutex[m](~stdmutexm@2001:470:69fc:105::1:4534)
2021-12-09 21:55:44 +0100RosarioPulella[m(~rosariopu@2001:470:69fc:105::a57)
2021-12-09 21:55:46 +0100Morrow(~quassel@bzq-110-168-31-106.red.bezeqint.net) (Remote host closed the connection)
2021-12-09 21:55:47 +0100 <aplainzetakind> Study this type signature and figure out how to make use of this function.
2021-12-09 21:55:51 +0100 <WilliamJ17> I have seen zip before, but not zipwith
2021-12-09 21:56:02 +0100alexfmpe[m](~alexfmpem@2001:470:69fc:105::38ba)
2021-12-09 21:56:17 +0100WilliamJ(~WilliamJ@wireless-student-pt10-182-232.lut.ac.uk) (Ping timeout: 256 seconds)
2021-12-09 21:56:28 +0100wysteriary[m](~wysteriar@2001:470:69fc:105::a42e)
2021-12-09 21:56:46 +0100 <WilliamJ17> so it takes 3 parameters and puts them into lists?
2021-12-09 21:57:09 +0100 <WilliamJ17> wait bo
2021-12-09 21:57:10 +0100 <WilliamJ17> no
2021-12-09 21:57:19 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl)
2021-12-09 21:57:25 +0100xddq[m](~xddqmatri@2001:470:69fc:105::bfd8)
2021-12-09 21:57:36 +0100 <aplainzetakind> No, (a -> b -> c) is a function type.
2021-12-09 21:57:46 +0100Morrow(~quassel@bzq-110-168-31-106.red.bezeqint.net)
2021-12-09 21:57:59 +0100 <aplainzetakind> It is a function which takes an a and a b and gives you a c.
2021-12-09 21:58:07 +0100bitonic(~bitonic@2001:470:69fc:105::1812)
2021-12-09 21:58:07 +0100 <WilliamJ17> Ok
2021-12-09 21:58:17 +0100 <WilliamJ17> So the c would be a list
2021-12-09 21:58:21 +0100 <aplainzetakind> No.
2021-12-09 21:58:26 +0100 <WilliamJ17> why not?
2021-12-09 21:58:31 +0100 <aplainzetakind> c can be anything.
2021-12-09 21:58:35 +0100 <WilliamJ17> ok
2021-12-09 21:58:53 +0100 <WilliamJ17> so
2021-12-09 21:58:57 +0100 <aplainzetakind> An example to inspect:
2021-12-09 21:59:01 +0100 <WilliamJ17> ok
2021-12-09 21:59:25 +0100jgeerds(~jgeerds@55d4ac73.access.ecotel.net)
2021-12-09 21:59:48 +0100 <aplainzetakind> > zipWith take [1,3,5] ["sdofijoi", "wqwqwqwq", "qwertyuio"]
2021-12-09 21:59:49 +0100 <lambdabot> ["s","wqw","qwert"]
2021-12-09 22:00:01 +0100 <aplainzetakind> :t take
2021-12-09 22:00:04 +0100 <lambdabot> Int -> [a] -> [a]
2021-12-09 22:00:05 +0100hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com) (Quit: Konversation terminated!)
2021-12-09 22:00:18 +0100 <WilliamJ17> so its taking the first, first 3 and first 5 elements of each index
2021-12-09 22:00:39 +0100 <aplainzetakind> Yes.
2021-12-09 22:01:14 +0100 <WilliamJ17> so for us, would we be using it to get each length, width and indentation for each rectangle?
2021-12-09 22:01:45 +0100 <aplainzetakind> ...of the string at the corresponding index would be a more precise way to put it.
2021-12-09 22:01:48 +0100jmcantrell(~jmcantrel@user/jmcantrell)
2021-12-09 22:02:00 +0100 <WilliamJ17> Ok
2021-12-09 22:02:06 +0100 <aplainzetakind> You mean height, width and indentation?
2021-12-09 22:02:12 +0100Orbstheorem(~orbstheor@2001:470:69fc:105::a56)
2021-12-09 22:02:21 +0100 <WilliamJ17> Yes, sorry for saying length keep saying it since that is what I wrote in the first place
2021-12-09 22:02:41 +0100 <aplainzetakind> We always have the same height, so that's fixed. we have created our lists of the indentations and widths.
2021-12-09 22:03:17 +0100 <aplainzetakind> Now we want a function of two parameters, width and indentation, but the function you already wrote takes three.
2021-12-09 22:03:30 +0100hgolden(~hgolden2@cpe-172-114-81-123.socal.res.rr.com)
2021-12-09 22:03:37 +0100 <WilliamJ17> yes, this one
2021-12-09 22:03:38 +0100kadoban(~kadoban@user/kadoban)
2021-12-09 22:03:38 +0100 <WilliamJ17> rectangle :: Int -> Int -> Int -> String
2021-12-09 22:03:38 +0100 <WilliamJ17> rectangle i m n = unlines replicate m (replicate i ' ' ++ (replicate n '*'))
2021-12-09 22:03:46 +0100Arathorn(~arathorn@2001:470:69fc:105::1f)
2021-12-09 22:04:29 +0100_ht(~quassel@82-169-194-8.biz.kpn.net) (Remote host closed the connection)
2021-12-09 22:04:30 +0100moats(~oats@user/oats)
2021-12-09 22:05:02 +0100 <WilliamJ17> so can we just get rid of m?
2021-12-09 22:05:03 +0100 <aplainzetakind> If you change `rectangle i m n` to `rectangle m i n` on the left hand side of the definition to change the order of the argument, the first parameter becomes the height right?
2021-12-09 22:05:11 +0100 <WilliamJ17> i shall give it a go
2021-12-09 22:05:33 +0100 <aplainzetakind> No you can't get rid of it, you will pass h to it in the other function.
2021-12-09 22:05:45 +0100 <WilliamJ17> ok
2021-12-09 22:06:01 +0100psydroid(~psydroid@user/psydroid)
2021-12-09 22:06:11 +0100 <WilliamJ17> ok slight problem, when I am trying to run I am getting a parse error due to where. I can comment this out for the time being right?
2021-12-09 22:06:24 +0100MatrixTravelerbo(~voyagert2@2001:470:69fc:105::22)
2021-12-09 22:06:27 +0100zwro[m](~zwromatri@2001:470:69fc:105::1d4)
2021-12-09 22:06:47 +0100InternetManaging(~imjmatrix@2001:470:69fc:105::1:2ea5)
2021-12-09 22:06:54 +0100surgeon[m](~surge9nma@2001:470:69fc:105::f585)
2021-12-09 22:06:59 +0100 <WilliamJ17> and Yes it will become the height
2021-12-09 22:07:00 +0100 <aplainzetakind> When you rearrange the parameter in the way I said, `rectangle 5`, for instance, becomes a function of two parameters, indentation and width, fit to be used in zipWith.
2021-12-09 22:07:27 +0100 <aplainzetakind> Just indent the lines following where more than where itself.
2021-12-09 22:07:28 +0100 <WilliamJ17> ok, I get you
2021-12-09 22:07:41 +0100schuelermine[m](~schuelerm@user/schuelermine)
2021-12-09 22:08:20 +0100 <WilliamJ17> https://paste.tomsmeding.com/pvtHk3yv what I currently have
2021-12-09 22:09:17 +0100jkachmar(~jkachmar@2001:470:69fc:105::c72d)
2021-12-09 22:09:22 +0100 <aplainzetakind> Now assemble all those things we mentioned in an expression to replace that `undefined` to produce a list of results of appropriate calls to `rectangle`..
2021-12-09 22:09:30 +0100 <WilliamJ17> ok
2021-12-09 22:09:47 +0100quantum(~quantum@user/quantum/x-8556232)
2021-12-09 22:09:47 +0100 <WilliamJ17> so, we need a zipWith function
2021-12-09 22:10:19 +0100 <aplainzetakind> You already have it.
2021-12-09 22:10:32 +0100 <aplainzetakind> Yo give appropriate parameters to it.
2021-12-09 22:10:42 +0100Deide(~deide@user/deide)
2021-12-09 22:10:46 +0100 <aplainzetakind> First is a function, then two lists.
2021-12-09 22:10:50 +0100 <WilliamJ17> Ok
2021-12-09 22:10:52 +0100 <WilliamJ17> I understand now
2021-12-09 22:10:54 +0100utk(~utk@2001:470:69fc:105::1:2fe0)
2021-12-09 22:11:04 +0100 <WilliamJ17> So
2021-12-09 22:11:11 +0100jophish(~jophish@2001:470:69fc:105::670)
2021-12-09 22:11:58 +0100 <aplainzetakind> You will get a type error because we are not done yet. Temporarily comment out the type signature of rectangles to avoid the complaints.
2021-12-09 22:12:18 +0100 <WilliamJ17> I am slightly confused, might seem like a rookie error. We need to do zip each corresponding index in widthseq and indentseq correct?
2021-12-09 22:12:25 +0100zfnmxt(~zfnmxtzfn@2001:470:69fc:105::2b32)
2021-12-09 22:12:44 +0100 <aplainzetakind> Yes.
2021-12-09 22:12:57 +0100 <aplainzetakind> zipWith rather.
2021-12-09 22:13:07 +0100acco[m](~accotedom@2001:470:69fc:105::1:3236)
2021-12-09 22:13:38 +0100deadmarshal(~deadmarsh@95.38.230.89)
2021-12-09 22:13:50 +0100DemiMarieObenour(~alwayscur@2001:470:69fc:105::4886)
2021-12-09 22:13:58 +0100soft(~soft@2001:470:69fc:105::c75)
2021-12-09 22:13:59 +0100 <WilliamJ17> Since I'm used to imperative languages, I keep thinkign I can just write i for each index, but in haskell that is not the case
2021-12-09 22:14:54 +0100 <EvanR> haskell is not opinionated on how you label your items hehe
2021-12-09 22:15:14 +0100 <aplainzetakind> You don't need to introduce any new names. You have all the building blocks now.
2021-12-09 22:15:22 +0100 <WilliamJ17> yeah lol im just trying to think what to put to make it so each index is zipped with one another
2021-12-09 22:15:42 +0100 <aplainzetakind> That's what zipWith does. You don't need to do anything.
2021-12-09 22:15:53 +0100 <EvanR> > zip [0..] "supercalifragilistic"
2021-12-09 22:15:54 +0100 <lambdabot> [(0,'s'),(1,'u'),(2,'p'),(3,'e'),(4,'r'),(5,'c'),(6,'a'),(7,'l'),(8,'i'),(9,...
2021-12-09 22:15:55 +0100dsrt^(~dsrt@wsip-98-188-240-142.mc.at.cox.net)
2021-12-09 22:16:03 +0100 <WilliamJ17> yeah like that
2021-12-09 22:16:24 +0100 <WilliamJ17> but with zipWith, you need a function first correct?
2021-12-09 22:16:29 +0100 <WilliamJ17> before the 2 lists
2021-12-09 22:16:31 +0100 <aplainzetakind> Yes.
2021-12-09 22:16:58 +0100 <WilliamJ17> I'm just confused what to put there, as I just saw with zip it has done it
2021-12-09 22:17:02 +0100 <EvanR> yeah then you avoid a tuple if you don't want one
2021-12-09 22:17:27 +0100 <aplainzetakind> The elements of the first list are used as the first parameter to the function, those of second for the second parameter of the function, and the resulting list is the list of the results of the function.
2021-12-09 22:18:22 +0100 <WilliamJ17> so is it just as simple as zipWith indentseq widthseq?
2021-12-09 22:18:31 +0100 <WilliamJ17> I dont think it is
2021-12-09 22:18:32 +0100 <aplainzetakind> zipWith f [x1, x2, x3] [y1, y2, y3] gives you [f x1 y1, f x2 y2, f x3 y3]
2021-12-09 22:18:41 +0100 <WilliamJ17> Yeah
2021-12-09 22:18:46 +0100 <aplainzetakind> zipWith needs a function to zip "With".
2021-12-09 22:19:01 +0100 <WilliamJ17> Yeah, thats what I'm stumped on since Im not sure what it is
2021-12-09 22:19:08 +0100 <WilliamJ17> is it just rectangle?
2021-12-09 22:19:10 +0100 <aplainzetakind> What function do you want to feed your widths and indentations into?
2021-12-09 22:19:27 +0100Topik[m](~topikmatr@2001:470:69fc:105::a082)
2021-12-09 22:19:37 +0100 <WilliamJ17> zipWith rectangle widthseq indentseq?
2021-12-09 22:19:40 +0100 <aplainzetakind> Almost, why did we reorder the parameters of `rectangle`?
2021-12-09 22:19:55 +0100 <WilliamJ17> so we got m first which was the height
2021-12-09 22:19:58 +0100 <aplainzetakind> How many parameters does rectangle take? How many are appropriate for zipWith?
2021-12-09 22:20:02 +0100 <WilliamJ17> so its m?
2021-12-09 22:20:20 +0100 <WilliamJ17> zipWith m widthseq indentseq?
2021-12-09 22:20:36 +0100 <aplainzetakind> m is not a function. (rectangle an_integer) however, is.
2021-12-09 22:20:59 +0100 <aplainzetakind> Do you have a good understanding of currying?
2021-12-09 22:21:01 +0100 <WilliamJ17> zipWith (rectangle m) widthseq indentseq
2021-12-09 22:21:14 +0100 <WilliamJ17> We have looked at it
2021-12-09 22:21:26 +0100 <aplainzetakind> Almost, except m is out of scope in where you want to put this. What do you need m to be?
2021-12-09 22:21:34 +0100river(~My_user_n@tilde.team/user/river)
2021-12-09 22:21:36 +0100 <river> hiy
2021-12-09 22:21:47 +0100cosimone(~user@2001:b07:ae5:db26:c24a:d20:4d91:1e20) (Ping timeout: 265 seconds)
2021-12-09 22:22:01 +0100 <WilliamJ17> wait
2021-12-09 22:22:25 +0100 <WilliamJ17> we made m as h here
2021-12-09 22:22:30 +0100 <aplainzetakind> Yes.
2021-12-09 22:22:42 +0100 <WilliamJ17> so is it just zipWith (rectangles h) widthseq indentseq?
2021-12-09 22:22:51 +0100 <aplainzetakind> rectangle h, not rectangles.
2021-12-09 22:22:53 +0100Christoph[m](~hpotsirhc@2001:470:69fc:105::2ff8)
2021-12-09 22:23:13 +0100 <WilliamJ17> ok, but why does that work if we havent input h in the rectangle function
2021-12-09 22:23:22 +0100 <aplainzetakind> Make sure the type signature is commented out.
2021-12-09 22:23:24 +0100 <WilliamJ17> its part of the rectangles function
2021-12-09 22:24:07 +0100 <dsal> Does ghc inline stuff within the same module by default?
2021-12-09 22:24:08 +0100reza[m](~rezaphone@2001:470:69fc:105::3eda)
2021-12-09 22:24:17 +0100 <sshine> is there a standard way to perform modular arithmetic in small spaces? e.g. if I do Z_{2^{32}} arithmetic directly in Word32, that's fine. but if I do Z_N arithmetic where N < 2^32 in Word32, then e.g. multiplication would overflow at the wrong place. is there a way to compensate either before or after multiplying if N is prime?
2021-12-09 22:24:19 +0100carmysilna(~brightly-@2001:470:69fc:105::2190)
2021-12-09 22:24:19 +0100 <aplainzetakind> Those are variable names. When you write f x = x + 1 and then write f y, it takes whatever y is and adds 1 to it.
2021-12-09 22:24:32 +0100 <WilliamJ17> ok
2021-12-09 22:24:59 +0100justosophy[m](~justosoph@2001:470:69fc:105::572f)
2021-12-09 22:25:02 +0100 <WilliamJ17> so I've commented out rectangles type signature, but I dont think if I run this, it will give me the solution?
2021-12-09 22:25:10 +0100 <WilliamJ17> still feel theres something else to do
2021-12-09 22:25:11 +0100 <aplainzetakind> The letters are not parts of the function, they represent places where things can be put.
2021-12-09 22:25:19 +0100 <aplainzetakind> Yes, see what this gives you first.
2021-12-09 22:25:21 +0100Pickchea(~private@user/pickchea)
2021-12-09 22:25:24 +0100_xor(~xor@dsl-50-5-233-169.fuse.net) (Read error: Connection reset by peer)
2021-12-09 22:25:31 +0100 <aplainzetakind> Running it is not a huge chore I suppose.
2021-12-09 22:25:35 +0100 <WilliamJ17> yeah lol
2021-12-09 22:25:49 +0100 <WilliamJ17> Ok, It's given me an error on rectangle since we changed the order
2021-12-09 22:26:02 +0100 <geekosaur> dsal, yes as long as it's not recursive (and a few other rules)
2021-12-09 22:26:05 +0100SawyerBergeron[m(~sawyerber@2001:470:69fc:105::3036)
2021-12-09 22:26:07 +0100 <WilliamJ17> https://paste.tomsmeding.com/4WpSDX8w
2021-12-09 22:26:49 +0100unclechu(~unclechu@2001:470:69fc:105::354)
2021-12-09 22:27:00 +0100 <geekosaur> dsal, https://downloads.haskell.org/ghc/latest/docs/html/users_guide/exts/pragmas.html#inline-pragma
2021-12-09 22:27:02 +0100 <WilliamJ17> I am confused as to why this has happened as all we did was change the order or i and m
2021-12-09 22:27:39 +0100 <aplainzetakind> You removed parentheses after unlines.
2021-12-09 22:27:42 +0100 <dsal> geekosaur: Thanks. My mental model is "ghc doesn't like inlining"
2021-12-09 22:27:52 +0100 <WilliamJ17> ok
2021-12-09 22:28:16 +0100TomasJakl[m](~jaklttchn@2001:470:69fc:105::a42)
2021-12-09 22:28:17 +0100 <geekosaur> dsal, mine is "ghc inlines anything it thinks won't explode on it"
2021-12-09 22:28:19 +0100 <WilliamJ17> Ok, I have gotten the same error as I did before on this I think
2021-12-09 22:28:32 +0100 <WilliamJ17> https://paste.tomsmeding.com/dMRlFJe6
2021-12-09 22:28:40 +0100 <geekosaur> you can either force it to inline anyway or fine-tune its notion of "won't explode"
2021-12-09 22:28:50 +0100lally(sid388228@id-388228.uxbridge.irccloud.com)
2021-12-09 22:29:45 +0100ilkecan[m](~ilkecanma@2001:470:69fc:105::1:79b)
2021-12-09 22:29:51 +0100ManofLetters[m](~manoflett@2001:470:69fc:105::3be)
2021-12-09 22:30:08 +0100 <aplainzetakind> I told you twice to comment out the type signature for rectangles, because we're not done yet.
2021-12-09 22:30:21 +0100 <WilliamJ17> oh sorry, I commented out it in rectangle
2021-12-09 22:30:23 +0100fendor[m](~fendormat@2001:470:69fc:105::fcbd)
2021-12-09 22:30:24 +0100 <aplainzetakind> It doesn't yet give what you declared in the signature.
2021-12-09 22:30:29 +0100xff0x(~xff0x@2001:1a81:5338:9c00:d04b:38a4:ed4b:d288) (Ping timeout: 265 seconds)
2021-12-09 22:31:01 +0100ServerStatsDisco(~serversta@2001:470:69fc:105::1a)
2021-12-09 22:31:03 +0100xff0x(~xff0x@2001:1a81:5338:9c00:9209:5fa4:fe4c:a1bd)
2021-12-09 22:31:17 +0100_xor(~xor@dsl-50-5-233-169.fuse.net)
2021-12-09 22:31:33 +0100merijn(~merijn@83-160-49-249.ip.xs4all.nl) (Ping timeout: 250 seconds)
2021-12-09 22:31:34 +0100 <WilliamJ17> Ok
2021-12-09 22:31:43 +0100 <WilliamJ17> [" \n \n \n"," **\n **\n **\n"," ****\n ****\n ****\n"] is my output
2021-12-09 22:31:53 +0100 <WilliamJ17> when I ran the function not in a putStr function
2021-12-09 22:32:14 +0100jinsun_(~jinsun@user/jinsun)
2021-12-09 22:32:41 +0100 <aplainzetakind> Can you paste the code?
2021-12-09 22:32:44 +0100 <[exa]> dsal: ghc _loves_ inlining but widely avoids all these kinds of traps and spikes
2021-12-09 22:32:45 +0100Magnus[m](~magthetch@2001:470:69fc:105::d1a7)
2021-12-09 22:32:57 +0100 <WilliamJ17> https://paste.tomsmeding.com/vfemMaf0
2021-12-09 22:34:05 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 22:34:17 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 22:34:39 +0100 <aplainzetakind> Well you see that the firs string in your list is rectangles of width 0, indented by 2 spaces, as opposed to rectangles of width 2 indented by zero spaces. Why ever could that be?
2021-12-09 22:34:50 +0100 <dsal> [exa]: I've had issues across modules where dumping INLINE directives everywhere helped.
2021-12-09 22:35:12 +0100 <[exa]> dumping as in "removing" or "adding"? :D
2021-12-09 22:35:13 +0100 <geekosaur> cross-module is another thing
2021-12-09 22:35:13 +0100 <WilliamJ17> is it because I've done widthseq and indentseq the wrong way round?
2021-12-09 22:35:25 +0100dschrempf(~dominik@070-207.dynamic.dsl.fonira.net) (Quit: WeeChat 3.3)
2021-12-09 22:35:43 +0100ongy[m](~ongymatri@2001:470:69fc:105::5018)
2021-12-09 22:35:48 +0100 <aplainzetakind> WilliamJ17: https://twitter.com/ThePracticalDev/status/720257210161311744
2021-12-09 22:36:06 +0100 <[exa]> anyway yeah that's actually one thing I wanted to ask a long time ago, is the (expectable) content of .hi files documented?
2021-12-09 22:36:12 +0100 <WilliamJ17> Ok, I've tried it and I get a different output which looks more like it should
2021-12-09 22:36:13 +0100WHatever666(~fuzzypixe@tchebychev.ensimag.fr) (Ping timeout: 240 seconds)
2021-12-09 22:36:14 +0100InternetCitizen(~fuzzypixe@eth-west-pareq2-46-193-4-100.wb.wifirst.net)
2021-12-09 22:36:19 +0100 <WilliamJ17> ["**\n**\n**\n"," ****\n ****\n ****\n"," ******\n ******\n ******\n"]
2021-12-09 22:36:56 +0100 <[exa]> WilliamJ17: btw what's the target of the exercise?
2021-12-09 22:37:02 +0100asdofindia-m(~akshaymat@2001:470:69fc:105::831)
2021-12-09 22:37:03 +0100 <aplainzetakind> Yes. Now what you have is [String] instead of String.
2021-12-09 22:37:07 +0100craige[m](~craigemcw@2001:470:69fc:105::35f1)
2021-12-09 22:37:12 +0100 <dsal> [exa]: littering my files with demands of INLINEs :)
2021-12-09 22:37:20 +0100 <aplainzetakind> Of course String is [Char].
2021-12-09 22:37:20 +0100 <WilliamJ17> [exa] it;s kind of an ascii art thing
2021-12-09 22:37:22 +0100 <dsal> I was just trying them here in this one module and it had no effect.
2021-12-09 22:37:35 +0100thomasjm[m](~thomasjmm@2001:470:69fc:105::c6d9)
2021-12-09 22:37:36 +0100 <[exa]> WilliamJ17: yeah I noticed but where's the hardness, I'd say
2021-12-09 22:37:47 +0100 <WilliamJ17> I'm a beginner
2021-12-09 22:38:11 +0100 <aplainzetakind> So you have [[Char]] when you need [Char].
2021-12-09 22:38:22 +0100 <WilliamJ17> Ok
2021-12-09 22:38:35 +0100 <[exa]> :t concat
2021-12-09 22:38:36 +0100 <lambdabot> Foldable t => t [a] -> [a]
2021-12-09 22:38:37 +0100river(~My_user_n@tilde.team/user/river) (WeeChat 2.3)
2021-12-09 22:38:51 +0100 <WilliamJ17> what does foldable mean?
2021-12-09 22:38:55 +0100 <aplainzetakind> https://hoogle.haskell.org/ this lets you search in Haskell libraries. Among other things, by type signatures.
2021-12-09 22:39:01 +0100 <geekosaur> % :t concat @[]
2021-12-09 22:39:01 +0100 <yahb> geekosaur: [[a]] -> [a]
2021-12-09 22:39:09 +0100 <WilliamJ17> (y)
2021-12-09 22:39:14 +0100 <aplainzetakind> Go there and search for [[a]] -> [a]
2021-12-09 22:39:20 +0100 <[exa]> WilliamJ17: 't' in there is any type that can be folded, e.g. a list (or a set, vector, ...)
2021-12-09 22:39:38 +0100 <WilliamJ17> ok so it concats a list of lists
2021-12-09 22:39:47 +0100 <geekosaur> Foldable means anything that you can do a foldl or foldr on. I just asked the other bot to give the type of concat with lists as the Foldable
2021-12-09 22:40:03 +0100 <geekosaur> (lambdabot doesn't yet understand that syntax)
2021-12-09 22:40:10 +0100 <WilliamJ17> Ok, I read about foldl and foldr but havent been introduced to them yet on the course
2021-12-09 22:40:13 +0100 <fizbin> Or a Vector of lists, or a Set of lists, or a ....
2021-12-09 22:40:48 +0100 <[exa]> WilliamJ17: anyway since it does [[a]] -> [a] and you need [[Char]] -> [Char], I hoped that it could help.
2021-12-09 22:40:50 +0100 <fizbin> But basically, yeah, it concats a (some container) of lists, because nearly any sensible container will have a Foldable instance.
2021-12-09 22:41:19 +0100 <aplainzetakind> WilliamJ17: So concat is what you need, but please note how to find "something that does whatever" on hoogle by putting in an appropriate type signature.
2021-12-09 22:41:35 +0100 <[exa]> dsal: that stuff is complicated, actually I have no idea if you can force-inline something across modules
2021-12-09 22:41:39 +0100 <aplainzetakind> Most things already exist.
2021-12-09 22:41:41 +0100meatfeather[m](~meatfeath@2001:470:69fc:105::1:3311)
2021-12-09 22:41:42 +0100wildsebastian(~wildsebas@2001:470:69fc:105::1:14b1)
2021-12-09 22:41:44 +0100 <WilliamJ17> Ok I appreciate you showing me hoogle, I didn't know about it
2021-12-09 22:41:55 +0100 <[exa]> hoogle is top
2021-12-09 22:42:05 +0100 <aplainzetakind> So concat what you have, and you're done.
2021-12-09 22:42:32 +0100 <WilliamJ17> So do I just concat the zipWith function?
2021-12-09 22:42:45 +0100ocramz[m](~ocramzmat@2001:470:69fc:105::1:35b0)
2021-12-09 22:42:46 +0100maralorn(~maralorn@2001:470:69fc:105::251)
2021-12-09 22:42:47 +0100marinelli[m](~marinelli@2001:470:69fc:105::2d8)
2021-12-09 22:43:05 +0100 <aplainzetakind> You could concat the zipWith function if the zipWith function were a list of lists of things.
2021-12-09 22:43:09 +0100 <[exa]> WilliamJ17: you mean the result of it, right?
2021-12-09 22:43:14 +0100 <aplainzetakind> You will concat the entire expression.
2021-12-09 22:43:21 +0100Tisoxin(~ikosit@user/ikosit)
2021-12-09 22:43:27 +0100 <WilliamJ17> ok, I got it working
2021-12-09 22:43:33 +0100 <WilliamJ17> putStr (rectangles 2 3 4)
2021-12-09 22:43:34 +0100 <WilliamJ17> ***
2021-12-09 22:43:35 +0100 <WilliamJ17>    ******
2021-12-09 22:43:36 +0100 <WilliamJ17>       *********
2021-12-09 22:43:37 +0100 <WilliamJ17>          ************
2021-12-09 22:43:40 +0100 <[exa]> oh noes
2021-12-09 22:43:55 +0100 <WilliamJ17> Thank you for being patient with me aplainzetakind
2021-12-09 22:43:58 +0100 <aplainzetakind> `concat $ ...` or `concat (...)`
2021-12-09 22:44:08 +0100 <aplainzetakind> But is this the intended behaviour?
2021-12-09 22:44:12 +0100 <WilliamJ17> Yeah
2021-12-09 22:44:16 +0100 <aplainzetakind> Really?
2021-12-09 22:44:26 +0100 <WilliamJ17> Thats what it looks like on the examples given on the exercise sheet
2021-12-09 22:44:30 +0100 <[exa]> WilliamJ17: please don't paste too many lines at once to IRC, you might get pwned by ops
2021-12-09 22:44:36 +0100 <WilliamJ17> (y)
2021-12-09 22:45:10 +0100 <WilliamJ17> If I per say wanted to create a mirror of it going in the other direction once its done all the rectangles, would that be possible?
2021-12-09 22:45:21 +0100 <aplainzetakind> Try changing to `indentseq = scanl (+) 0 widthseq`
2021-12-09 22:45:23 +0100 <WilliamJ17> so going back down to 0 on indentation
2021-12-09 22:45:31 +0100 <aplainzetakind> That would be nicer behaviour I think.
2021-12-09 22:45:33 +0100 <WilliamJ17> i'll give it a go to see what happens
2021-12-09 22:45:36 +0100 <aplainzetakind> And you're welcome.
2021-12-09 22:45:39 +0100 <WilliamJ17> what does scanl do>
2021-12-09 22:45:40 +0100 <WilliamJ17> ?
2021-12-09 22:45:40 +0100 <[exa]> WilliamJ17: just expand the lists that you have there with more specifications?
2021-12-09 22:45:44 +0100 <aplainzetakind> Figure it out.
2021-12-09 22:45:51 +0100 <[exa]> :t scanl
2021-12-09 22:45:52 +0100 <lambdabot> (b -> a -> b) -> b -> [a] -> [b]
2021-12-09 22:46:15 +0100 <WilliamJ17> so it essentially feeds it onto the next
2021-12-09 22:46:17 +0100deadmarshal(~deadmarsh@95.38.230.89) (Ping timeout: 250 seconds)
2021-12-09 22:46:26 +0100 <[exa]> yap
2021-12-09 22:46:32 +0100 <WilliamJ17> [exa] Yeah I'm going to try that
2021-12-09 22:46:38 +0100 <WilliamJ17> Want to try test myself
2021-12-09 22:46:56 +0100smartin(~Thunderbi@88.135.18.171) (Quit: smartin)
2021-12-09 22:47:07 +0100iammrinal0[m](~iammrinal@2001:470:69fc:105::1:2248)
2021-12-09 22:47:12 +0100rednaZ[m](~r3dnazmat@2001:470:69fc:105::ba70)
2021-12-09 22:47:16 +0100 <WilliamJ17> so I'd have to make the lists go back down to 0
2021-12-09 22:47:27 +0100 <int-e> [exa]: scroll back one hour ;-)
2021-12-09 22:48:19 +0100 <aplainzetakind> A design improvement could be to remove unlines from rectangle, so it gives you a list of the lines. Then you can call lines at the end to the result of concat.
2021-12-09 22:48:34 +0100 <[exa]> int-e: ayay.
2021-12-09 22:48:45 +0100 <hololeap> sshine: this first example looks like what you're looking for, although it's written in C: https://en.wikipedia.org/wiki/Modular_arithmetic#Example_implementations
2021-12-09 22:48:51 +0100 <WilliamJ17> unlines gives the new lines doesnt it or did i read into the function wrong
2021-12-09 22:49:04 +0100 <aplainzetakind> Then if you `fmap reverse` before that last unlines is applied, you'll get each line recersed.
2021-12-09 22:49:20 +0100boxscape(~boxscape@user/boxscape)
2021-12-09 22:49:24 +0100 <WilliamJ17> (y)
2021-12-09 22:49:31 +0100 <WilliamJ17> what is the difference between fmap and map?
2021-12-09 22:49:38 +0100 <[exa]> WilliamJ17: yeah but you can keep the lines nicely separate for longer, then smash them together with one big unlines
2021-12-09 22:49:51 +0100 <WilliamJ17> I see
2021-12-09 22:49:55 +0100 <aplainzetakind> map is lists only fmap is polymorphic.
2021-12-09 22:50:01 +0100 <aplainzetakind> Or is it?
2021-12-09 22:50:08 +0100 <[exa]> likely saving a bit of code
2021-12-09 22:50:11 +0100 <aplainzetakind> > fmap succ $ Just 1
2021-12-09 22:50:12 +0100 <lambdabot> Just 2
2021-12-09 22:50:17 +0100 <aplainzetakind> > map succ $ Just 1
2021-12-09 22:50:19 +0100 <lambdabot> error:
2021-12-09 22:50:19 +0100 <lambdabot> • Couldn't match expected type ‘[b]’ with actual type ‘Maybe a0’
2021-12-09 22:50:19 +0100 <lambdabot> • In the second argument of ‘($)’, namely ‘Just 1’
2021-12-09 22:50:22 +0100 <aplainzetakind> Yes.
2021-12-09 22:50:25 +0100 <WilliamJ17> Ok
2021-12-09 22:50:38 +0100 <WilliamJ17> is "Just" a built in function within haskell
2021-12-09 22:50:50 +0100 <[exa]> no
2021-12-09 22:50:53 +0100ericson2314(~ericson23@2001:470:69fc:105::70c)
2021-12-09 22:50:55 +0100 <aplainzetakind> It's a data constructor of the type Maybe.
2021-12-09 22:51:09 +0100 <[exa]> it's in the standard library, but not "built in" per se
2021-12-09 22:51:13 +0100 <WilliamJ17> Ok what is it used for?
2021-12-09 22:51:22 +0100 <[exa]> for distinguishing stuff from Nothing
2021-12-09 22:51:31 +0100 <aplainzetakind> To model computations which may not return meaningful results.
2021-12-09 22:51:38 +0100 <geekosaur> some languages call it "optional"
2021-12-09 22:52:01 +0100 <WilliamJ17> Ok, I kind of understand that
2021-12-09 22:52:01 +0100 <aplainzetakind> Something like safeDiv x y = if y == 0 then Nothing else Just (x / y)
2021-12-09 22:52:10 +0100 <WilliamJ17> ah right
2021-12-09 22:52:22 +0100 <dsal> Some languages call it "null pointer exception"
2021-12-09 22:52:22 +0100 <WilliamJ17> so its essentially a blank line
2021-12-09 22:52:37 +0100denbrahe[m](~denbrahem@2001:470:69fc:105::19c0)
2021-12-09 22:52:38 +0100JoelMcCracken[m](~joelmccra@2001:470:69fc:105::8405)
2021-12-09 22:52:39 +0100 <[exa]> blank value, yes.
2021-12-09 22:52:40 +0100inkbottle[m](~inkbottle@2001:470:69fc:105::2ff5)
2021-12-09 22:53:03 +0100sm(~sm@plaintextaccounting/sm)
2021-12-09 22:53:05 +0100siraben(~siraben@user/siraben)
2021-12-09 22:53:13 +0100 <WilliamJ17> I see
2021-12-09 22:53:26 +0100 <aplainzetakind> WilliamJ17: I suggest reading lyah.
2021-12-09 22:53:28 +0100maerwald[m](~maerwaldm@2001:470:69fc:105::1ee)
2021-12-09 22:53:38 +0100 <dsal> If you think about it in terms of value cardinality, Maybe adds one additional value to whatever type it's applied to. So if you have a Maybe Bool, there are now three possibilities. Nothing, Just True, and Just False.
2021-12-09 22:53:45 +0100 <WilliamJ17> learn you a haskell? I have been looking at it when doing previous exercises
2021-12-09 22:53:52 +0100gehmehgeh(~user@user/gehmehgeh)
2021-12-09 22:55:04 +0100 <aplainzetakind> Are those exercises for a course?
2021-12-09 22:55:10 +0100 <aplainzetakind> Where do they come from?
2021-12-09 22:55:23 +0100 <WilliamJ17> they're weekly exercises set by our lecturer
2021-12-09 22:55:29 +0100benjamin[m]12(~benjaminm@2001:470:69fc:105::1:3f2f)
2021-12-09 22:55:37 +0100 <WilliamJ17> for practice
2021-12-09 22:55:40 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl)
2021-12-09 22:55:51 +0100 <dsal> Advent of Code is currently giving us daily exercises that are pretty fun.
2021-12-09 22:56:21 +0100 <WilliamJ17> I come from an imperative background so I have been trying to do some AoC in python whenever I can
2021-12-09 22:56:37 +0100son0p(~ff@2800:484:1d81:b700:d40b:900:b387:320)
2021-12-09 22:56:48 +0100 <dsal> Your background can be repaired with time and practice.
2021-12-09 22:57:34 +0100 <WilliamJ17> I have used functional concepts such as lambdas before when doing exercises on per say hackerrank so I did run into it before I did start the course
2021-12-09 22:58:23 +0100 <dsal> I'm not sure I'd call lambda a particularly significant functional concept, but nobody can agree on what functional programming is. heh
2021-12-09 22:59:21 +0100 <WilliamJ17> I thought haskell is based upon the lambda? Or am I being silly
2021-12-09 22:59:38 +0100vicfred(~vicfred@user/vicfred)
2021-12-09 22:59:50 +0100 <[exa]> you mean lambda calculus?
2021-12-09 23:00:11 +0100 <[exa]> (in that case, yeah, mostly, but that's by far not only lambdas)
2021-12-09 23:00:41 +0100 <int-e> > (\f g x -> f x + g x) (\x -> 2 * x) (\x -> 3 - x) 42
2021-12-09 23:00:43 +0100 <lambdabot> 45
2021-12-09 23:00:48 +0100 <dsal> Yeah, lambda calculus, but if you didn't have lambda in haskell, you'd still be able to do all the functional things. Just some stuff would be annoying because you'd have to name things you didn't' want to name.
2021-12-09 23:01:16 +0100 <exarkun> WilliamJ17: If you are thinking of "lambda" from Python then it's really just syntactic sugar for a certain subset of "regular" Python functions. It doesn't have much to do with anything Haskell is based on.
2021-12-09 23:01:40 +0100 <WilliamJ17> yeah I must mean lambda calculus
2021-12-09 23:01:50 +0100 <WilliamJ17> exarkun ah I see
2021-12-09 23:02:18 +0100 <dsal> At a high level, functional programming (to me), is more about telling the computer what you want done without telling it all the details of how to do it.
2021-12-09 23:02:19 +0100 <int-e> there are lambda abstractions but it's often useful to name functions... so they're kind of rare
2021-12-09 23:02:48 +0100 <exarkun> dsal: Like what we do in SQL, right
2021-12-09 23:02:49 +0100 <int-e> (it's also a matter of style; some people use them more than others)
2021-12-09 23:03:07 +0100 <dsal> exarkun: Yeah, kind of.
2021-12-09 23:03:09 +0100dmenz(~dmenz@2804:14d:5cd4:5e94::1)
2021-12-09 23:03:54 +0100MOTERF(~MOTERF@105.66.3.166)
2021-12-09 23:04:19 +0100 <int-e> There's also useful operators that avoid lambdas. Function composition is a commone one: `f . g` can be used instead of `\x -> f (g x)`.
2021-12-09 23:04:31 +0100 <WilliamJ17> Yeah I read about function composition
2021-12-09 23:04:40 +0100 <WilliamJ17> Haven't used it though yet
2021-12-09 23:04:41 +0100 <xsperry> also partial application and setions
2021-12-09 23:04:49 +0100chomwitt(~chomwitt@2a02:587:dc0d:3700:12c3:7bff:fe6d:d374) (Ping timeout: 252 seconds)
2021-12-09 23:04:56 +0100 <xsperry> instead of (\x -> x + 1) you can just do (+1)
2021-12-09 23:04:56 +0100 <int-e> *sections
2021-12-09 23:05:03 +0100 <xsperry> ^^
2021-12-09 23:05:10 +0100 <dsal> A friend of mine is trying to do some of the AoC stuff in Haskell with ~no FP background. His first attempt at the first problem was pages of code opening a file and reading it line by line while trying to convert stuff and accumulate it and all this other junk. It was a screenful of code to do something like `map read . words <$> readFile p`
2021-12-09 23:05:33 +0100 <dsal> One of the greatest things we get from FP is being able to actually compose things.
2021-12-09 23:05:44 +0100 <int-e> :t interact
2021-12-09 23:05:45 +0100 <lambdabot> (String -> String) -> IO ()
2021-12-09 23:06:12 +0100 <dsal> It takes so much planning to be able to do any sort of composition in most languages.
2021-12-09 23:06:20 +0100 <WilliamJ17> I have found since I started the FP course that in haskell and maybe FP in general, everything does seem shorter
2021-12-09 23:06:29 +0100 <int-e> (it's my get-out-of-IO-for-free card ;-)
2021-12-09 23:07:06 +0100 <dsal> WilliamJ17: It's not so much shorter, it's just that you write the parts you care about and don't have to spend as much effort describing *how* to do all the things (at least, not in the same place).
2021-12-09 23:07:09 +0100nebu(~user@user/wavion)
2021-12-09 23:07:15 +0100 <xsperry> > map (\xs -> map (\x -> x * 10) xs) [[1,2,3],[4,5,6]]
2021-12-09 23:07:17 +0100 <lambdabot> [[10,20,30],[40,50,60]]
2021-12-09 23:07:21 +0100 <xsperry> now compare that to:
2021-12-09 23:07:25 +0100 <int-e> FP is really good at abstraction
2021-12-09 23:07:28 +0100aveltras[m](~aveltrasm@2001:470:69fc:105::3ef9)
2021-12-09 23:07:29 +0100 <xsperry> > map (map (*10)) [[1,2,3],[4,5,6]]
2021-12-09 23:07:30 +0100 <lambdabot> [[10,20,30],[40,50,60]]
2021-12-09 23:08:17 +0100 <dsal> > [[1,2,3],[4,5,6]] & traversed . traversed *~ 10
2021-12-09 23:08:19 +0100 <lambdabot> [[10,20,30],[40,50,60]]
2021-12-09 23:08:27 +0100 <dsal> If you want clarity, you have to use lens.
2021-12-09 23:08:49 +0100 <int-e> ...after spending years of mastering the vocabulary
2021-12-09 23:08:59 +0100 <exarkun> int-e++
2021-12-09 23:09:02 +0100 <dsal> You only need that to read it.
2021-12-09 23:09:02 +0100kennyd(~bc8147f2@cerf.good1.com)
2021-12-09 23:09:35 +0100 <WilliamJ17> mhm that looks quite complex dsal to me at least
2021-12-09 23:09:36 +0100MOTERF(~MOTERF@105.66.3.166) (Remote host closed the connection)
2021-12-09 23:09:59 +0100dmenz(~dmenz@2804:14d:5cd4:5e94::1) (Quit: Leaving)
2021-12-09 23:10:06 +0100 <dsal> WilliamJ17: It's a whole category of concepts that you aren't expected to care about.
2021-12-09 23:10:12 +0100 <WilliamJ17> ah
2021-12-09 23:10:27 +0100 <int-e> > ((10*) <$>) <$> [[1,2,3],[4,5,6]] -- needed more sections
2021-12-09 23:10:28 +0100 <lambdabot> [[10,20,30],[40,50,60]]
2021-12-09 23:10:32 +0100 <dsal> It solves a class of problems, but has overlap with other solutions that may fit better. Such as (fmap.fmap)
2021-12-09 23:10:57 +0100 <dsal> @pl (((10*) <$>) <$>)
2021-12-09 23:10:57 +0100 <lambdabot> (((10 *) <$>) <$>)
2021-12-09 23:11:06 +0100 <dsal> not even pl can make that worse
2021-12-09 23:11:11 +0100 <int-e> <$> is too new for pl
2021-12-09 23:12:23 +0100 <dsal> > let (<$$>) = (fmap.fmap) in (10 *) <$$> [[10,20,30],[40,50,60]]
2021-12-09 23:12:25 +0100 <lambdabot> [[100,200,300],[400,500,600]]
2021-12-09 23:12:32 +0100 <dsal> oops, pasted the wrong input
2021-12-09 23:13:14 +0100 <kennyd> I'd prefer <<$>>
2021-12-09 23:13:28 +0100 <dsal> > let (<<$>>) = (fmap.fmap) in (10 *) <<$>> [[10,20,30],[40,50,60]]
2021-12-09 23:13:29 +0100 <lambdabot> [[100,200,300],[400,500,600]]
2021-12-09 23:13:33 +0100 <dsal> Yeah, that makes sense.
2021-12-09 23:13:58 +0100 <dsal> I've never written one of those. Starts getting bad once you start getting really deep, though.
2021-12-09 23:14:16 +0100 <kennyd> yeah, we are approaching caaddr
2021-12-09 23:14:18 +0100 <geekosaur> next someone'll drag in type level programming
2021-12-09 23:14:21 +0100 <dsal> > let (<<<$>>>) = (fmap.fmap.fmap) in (10 *) <<<$>>> cycle [[10,20,30],[40,50,60]]
2021-12-09 23:14:22 +0100 <lambdabot> error:
2021-12-09 23:14:23 +0100 <lambdabot> • Ambiguous type variable ‘f0’ arising from a use of ‘show_M827152648093...
2021-12-09 23:14:23 +0100 <lambdabot> prevents the constraint ‘(Show (f0 Integer))’ from being solved.
2021-12-09 23:14:40 +0100 <dsal> > let (<<<$>>>) = (fmap.fmap.fmap) in (10 *) <<<$>>> repeat [[10,20,30],[40,50,60]]
2021-12-09 23:14:41 +0100 <lambdabot> [[[100,200,300],[400,500,600]],[[100,200,300],[400,500,600]],[[100,200,300],...
2021-12-09 23:17:45 +0100ppseafield[m](~elementpp@2001:470:69fc:105::1:250a)
2021-12-09 23:17:55 +0100 <kennyd> hopefully we didn't scare WilliamJ17 away with these silly examples. :P
2021-12-09 23:18:02 +0100hsiktas[m](~hsiktasma@2001:470:69fc:105::30d4)
2021-12-09 23:18:35 +0100 <dsal> I think structured learning is more helpful than just seeing random stuff and asking questions about how to say French idioms in Japanese.
2021-12-09 23:18:52 +0100 <dsal> Imperative instincts are hard to unlearn.
2021-12-09 23:19:22 +0100smichel17[m](~smichel17@2001:470:69fc:105::2d32)
2021-12-09 23:20:38 +0100 <kennyd> that's true. but curiosity and interest is often sparked by the first two, before deciding to spend more time learning something
2021-12-09 23:21:54 +0100fizbin(~fizbin@c-73-33-197-160.hsd1.nj.comcast.net) (Remote host closed the connection)
2021-12-09 23:22:04 +0100smichel17[m](~smichel17@2001:470:69fc:105::2d32) (Read error: Connection reset by peer)
2021-12-09 23:22:04 +0100hsiktas[m](~hsiktasma@2001:470:69fc:105::30d4) (Write error: Connection reset by peer)
2021-12-09 23:22:04 +0100JoelMcCracken[m](~joelmccra@2001:470:69fc:105::8405) (Write error: Connection reset by peer)
2021-12-09 23:22:04 +0100benjamin[m]12(~benjaminm@2001:470:69fc:105::1:3f2f) (Write error: Connection reset by peer)
2021-12-09 23:22:04 +0100aveltras[m](~aveltrasm@2001:470:69fc:105::3ef9) (Read error: Connection reset by peer)
2021-12-09 23:22:04 +0100marinelli[m](~marinelli@2001:470:69fc:105::2d8) (Read error: Connection reset by peer)
2021-12-09 23:22:05 +0100ppseafield[m](~elementpp@2001:470:69fc:105::1:250a) (Read error: Connection reset by peer)
2021-12-09 23:22:05 +0100sm(~sm@plaintextaccounting/sm) (Write error: Connection reset by peer)
2021-12-09 23:22:05 +0100maralorn(~maralorn@2001:470:69fc:105::251) (Write error: Connection reset by peer)
2021-12-09 23:22:05 +0100ServerStatsDisco(~serversta@2001:470:69fc:105::1a) (Read error: Connection reset by peer)
2021-12-09 23:22:05 +0100alexfmpe[m](~alexfmpem@2001:470:69fc:105::38ba) (Read error: Connection reset by peer)
2021-12-09 23:22:05 +0100carmysilna(~brightly-@2001:470:69fc:105::2190) (Read error: Connection reset by peer)
2021-12-09 23:22:05 +0100ericson2314(~ericson23@2001:470:69fc:105::70c) (Write error: Connection reset by peer)
2021-12-09 23:22:05 +0100wildsebastian(~wildsebas@2001:470:69fc:105::1:14b1) (Read error: Connection reset by peer)
2021-12-09 23:22:05 +0100schuelermine[m](~schuelerm@user/schuelermine) (Write error: Connection reset by peer)
2021-12-09 23:22:05 +0100maerwald[m](~maerwaldm@2001:470:69fc:105::1ee) (Read error: Connection reset by peer)
2021-12-09 23:22:05 +0100std_mutex[m](~stdmutexm@2001:470:69fc:105::1:4534) (Write error: Connection reset by peer)
2021-12-09 23:22:05 +0100jkachmar(~jkachmar@2001:470:69fc:105::c72d) (Read error: Connection reset by peer)
2021-12-09 23:22:05 +0100boxscape(~boxscape@user/boxscape) (Write error: Connection reset by peer)
2021-12-09 23:22:05 +0100iammrinal0[m](~iammrinal@2001:470:69fc:105::1:2248) (Write error: Connection reset by peer)
2021-12-09 23:22:05 +0100fendor[m](~fendormat@2001:470:69fc:105::fcbd) (Write error: Connection reset by peer)
2021-12-09 23:22:05 +0100quantum(~quantum@user/quantum/x-8556232) (Write error: Connection reset by peer)
2021-12-09 23:22:05 +0100meatfeather[m](~meatfeath@2001:470:69fc:105::1:3311) (Write error: Connection reset by peer)
2021-12-09 23:22:05 +0100Topik[m](~topikmatr@2001:470:69fc:105::a082) (Read error: Connection reset by peer)
2021-12-09 23:22:05 +0100rednaZ[m](~r3dnazmat@2001:470:69fc:105::ba70) (Write error: Connection reset by peer)
2021-12-09 23:22:05 +0100jinsun_(~jinsun@user/jinsun) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100justosophy[m](~justosoph@2001:470:69fc:105::572f) (Read error: Connection reset by peer)
2021-12-09 23:22:06 +0100inkbottle[m](~inkbottle@2001:470:69fc:105::2ff5) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100Orbstheorem(~orbstheor@2001:470:69fc:105::a56) (Read error: Connection reset by peer)
2021-12-09 23:22:06 +0100Deide(~deide@user/deide) (Read error: Connection reset by peer)
2021-12-09 23:22:06 +0100surgeon[m](~surge9nma@2001:470:69fc:105::f585) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100moats(~oats@user/oats) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100InternetManaging(~imjmatrix@2001:470:69fc:105::1:2ea5) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100jmcantrell(~jmcantrel@user/jmcantrell) (Read error: Connection reset by peer)
2021-12-09 23:22:06 +0100zwro[m](~zwromatri@2001:470:69fc:105::1d4) (Read error: Connection reset by peer)
2021-12-09 23:22:06 +0100denbrahe[m](~denbrahem@2001:470:69fc:105::19c0) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100ManofLetters[m](~manoflett@2001:470:69fc:105::3be) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100ocramz[m](~ocramzmat@2001:470:69fc:105::1:35b0) (Read error: Connection reset by peer)
2021-12-09 23:22:06 +0100acco[m](~accotedom@2001:470:69fc:105::1:3236) (Read error: Connection reset by peer)
2021-12-09 23:22:06 +0100craige[m](~craigemcw@2001:470:69fc:105::35f1) (Read error: Connection reset by peer)
2021-12-09 23:22:06 +0100RosarioPulella[m(~rosariopu@2001:470:69fc:105::a57) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100kadoban(~kadoban@user/kadoban) (Read error: Connection reset by peer)
2021-12-09 23:22:06 +0100Arathorn(~arathorn@2001:470:69fc:105::1f) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100TomasJakl[m](~jaklttchn@2001:470:69fc:105::a42) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100utk(~utk@2001:470:69fc:105::1:2fe0) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100wysteriary[m](~wysteriar@2001:470:69fc:105::a42e) (Write error: Connection reset by peer)
2021-12-09 23:22:06 +0100SawyerBergeron[m(~sawyerber@2001:470:69fc:105::3036) (Read error: Connection reset by peer)
2021-12-09 23:22:07 +0100xddq[m](~xddqmatri@2001:470:69fc:105::bfd8) (Read error: Connection reset by peer)
2021-12-09 23:22:07 +0100unclechu(~unclechu@2001:470:69fc:105::354) (Read error: Connection reset by peer)
2021-12-09 23:22:07 +0100bitonic(~bitonic@2001:470:69fc:105::1812) (Write error: Connection reset by peer)
2021-12-09 23:22:07 +0100soft(~soft@2001:470:69fc:105::c75) (Read error: Connection reset by peer)
2021-12-09 23:22:07 +0100thomasjm[m](~thomasjmm@2001:470:69fc:105::c6d9) (Write error: Connection reset by peer)
2021-12-09 23:22:07 +0100zfnmxt(~zfnmxtzfn@2001:470:69fc:105::2b32) (Read error: Connection reset by peer)
2021-12-09 23:22:07 +0100Tisoxin(~ikosit@user/ikosit) (Write error: Connection reset by peer)
2021-12-09 23:22:07 +0100psydroid(~psydroid@user/psydroid) (Write error: Connection reset by peer)
2021-12-09 23:22:07 +0100ongy[m](~ongymatri@2001:470:69fc:105::5018) (Write error: Connection reset by peer)
2021-12-09 23:22:07 +0100DemiMarieObenour(~alwayscur@2001:470:69fc:105::4886) (Read error: Connection reset by peer)
2021-12-09 23:22:07 +0100MatrixTravelerbo(~voyagert2@2001:470:69fc:105::22) (Read error: Connection reset by peer)
2021-12-09 23:22:07 +0100Magnus[m](~magthetch@2001:470:69fc:105::d1a7) (Write error: Connection reset by peer)
2021-12-09 23:22:07 +0100reza[m](~rezaphone@2001:470:69fc:105::3eda) (Write error: Connection reset by peer)
2021-12-09 23:22:07 +0100asdofindia-m(~akshaymat@2001:470:69fc:105::831) (Write error: Connection reset by peer)
2021-12-09 23:22:07 +0100ilkecan[m](~ilkecanma@2001:470:69fc:105::1:79b) (Read error: Connection reset by peer)
2021-12-09 23:22:07 +0100siraben(~siraben@user/siraben) (Write error: Connection reset by peer)
2021-12-09 23:22:07 +0100jophish(~jophish@2001:470:69fc:105::670) (Write error: Connection reset by peer)
2021-12-09 23:22:07 +0100Christoph[m](~hpotsirhc@2001:470:69fc:105::2ff8) (Read error: Connection reset by peer)
2021-12-09 23:22:12 +0100 <dsal> Yeah. It's possibly counterintuitive, but I like working in Haskell because it's easier than just about any other language I've worked in.
2021-12-09 23:22:26 +0100 <dsal> Which is a rather long list.
2021-12-09 23:23:39 +0100michalz(~michalz@185.246.204.55) (Remote host closed the connection)
2021-12-09 23:24:44 +0100jchia[m](~jchiamatr@2001:470:69fc:105::c50b)
2021-12-09 23:26:37 +0100lavaman(~lavaman@98.38.249.169) (Remote host closed the connection)
2021-12-09 23:29:41 +0100 <monochrom> Yeah, "shorter code" is a very first impression but is also just a side effect. The benefit of Haskell I go for is "less micromanagement".
2021-12-09 23:29:41 +0100lortabac(~lortabac@2a01:e0a:541:b8f0:36fe:413:d066:5593) (Quit: WeeChat 2.8)
2021-12-09 23:29:41 +0100MatrixTravelerbo(~voyagert2@2001:470:69fc:105::22)
2021-12-09 23:29:41 +0100fgaz(~fgaz@2001:470:69fc:105::842)
2021-12-09 23:29:42 +0100peddie(~peddie@2001:470:69fc:105::25d)
2021-12-09 23:29:42 +0100cdsmith(~cdsmithma@2001:470:69fc:105::284)
2021-12-09 23:29:42 +0100thomasjm[m](~thomasjmm@2001:470:69fc:105::c6d9)
2021-12-09 23:29:56 +0100bb010g(~bb010g@2001:470:69fc:105::9a5)
2021-12-09 23:29:56 +0100ServerStatsDisco(~serversta@2001:470:69fc:105::1a)
2021-12-09 23:29:56 +0100amesgen[m](~amesgenm]@2001:470:69fc:105::82b)
2021-12-09 23:29:56 +0100the-coot[m](~the-cootm@2001:470:69fc:105::95f)
2021-12-09 23:29:56 +0100moats(~oats@user/oats)
2021-12-09 23:29:57 +0100nunggu(~q@gateway/tor-sasl/nunggu) (Ping timeout: 276 seconds)
2021-12-09 23:29:58 +0100 <Square> Right, thats what im trying say to my colleagues at work. But they assume its just massive extra work.
2021-12-09 23:30:06 +0100 <Square> to*
2021-12-09 23:30:09 +0100soft(~soft@2001:470:69fc:105::c75)
2021-12-09 23:30:09 +0100zfnmxt(~zfnmxtzfn@2001:470:69fc:105::2b32)
2021-12-09 23:30:22 +0100oak-(~oakuniver@2001:470:69fc:105::fcd)
2021-12-09 23:30:22 +0100kadoban(~kadoban@user/kadoban)
2021-12-09 23:30:22 +0100bitonic(~bitonic@2001:470:69fc:105::1812)
2021-12-09 23:30:22 +0100jophish(~jophish@2001:470:69fc:105::670)
2021-12-09 23:30:22 +0100ericson2314(~ericson23@2001:470:69fc:105::70c)
2021-12-09 23:30:23 +0100Arathorn(~arathorn@2001:470:69fc:105::1f)
2021-12-09 23:30:23 +0100Ollie[m](~ollieocha@2001:470:69fc:105::41a5)
2021-12-09 23:30:23 +0100unclechu(~unclechu@2001:470:69fc:105::354)
2021-12-09 23:30:23 +0100rednaZ[m](~r3dnazmat@2001:470:69fc:105::ba70)
2021-12-09 23:30:35 +0100xddq[m](~xddqmatri@2001:470:69fc:105::bfd8)
2021-12-09 23:30:35 +0100maralorn(~maralorn@2001:470:69fc:105::251)
2021-12-09 23:30:35 +0100denbrahe[m](~denbrahem@2001:470:69fc:105::19c0)
2021-12-09 23:30:48 +0100reza[m](~rezaphone@2001:470:69fc:105::3eda)
2021-12-09 23:30:48 +0100quantum(~quantum@user/quantum/x-8556232)
2021-12-09 23:30:48 +0100marinelli[m](~marinelli@2001:470:69fc:105::2d8)
2021-12-09 23:30:48 +0100hsiktas[m](~hsiktasma@2001:470:69fc:105::30d4)
2021-12-09 23:30:49 +0100 <monochrom> But self-selection bias implies that programmers are control freaks. Good luck telling them to even learn to let go.
2021-12-09 23:31:01 +0100chizil[m](~chizilmat@2001:470:69fc:105::1:34ab)
2021-12-09 23:31:16 +0100craige[m](~craigemcw@2001:470:69fc:105::35f1)
2021-12-09 23:31:16 +0100schuelermine[m](~schuelerm@user/schuelermine)
2021-12-09 23:31:16 +0100sm(~sm@plaintextaccounting/sm)
2021-12-09 23:31:30 +0100Orbstheorem(~orbstheor@2001:470:69fc:105::a56)
2021-12-09 23:31:36 +0100nunggu(~q@gateway/tor-sasl/nunggu)
2021-12-09 23:31:41 +0100 <hpc> on a mac they are command freaks
2021-12-09 23:31:42 +0100justosophy[m](~justosoph@2001:470:69fc:105::572f)
2021-12-09 23:31:45 +0100 <monochrom> Or at least, self-selection bias of von-Neumann-model (so, mainstream languages, the lot of them) programmers.
2021-12-09 23:31:54 +0100 <monochrom> hahaha
2021-12-09 23:31:54 +0100ppseafield[m](~elementpp@2001:470:69fc:105::1:250a)
2021-12-09 23:31:54 +0100Deide(~deide@user/deide)
2021-12-09 23:31:55 +0100hughjfchen[m](~hughjfche@2001:470:69fc:105::c29d)
2021-12-09 23:31:55 +0100Artem[m](~artemtype@2001:470:69fc:105::75b)
2021-12-09 23:31:55 +0100Christoph[m](~hpotsirhc@2001:470:69fc:105::2ff8)
2021-12-09 23:31:55 +0100psydroid(~psydroid@user/psydroid)
2021-12-09 23:32:07 +0100wysteriary[m](~wysteriar@2001:470:69fc:105::a42e)
2021-12-09 23:32:07 +0100zwro[m](~zwromatri@2001:470:69fc:105::1d4)
2021-12-09 23:32:22 +0100fsckskye[m](~kmatrixth@2001:470:69fc:105::1:3b2f)
2021-12-09 23:32:22 +0100Topik[m](~topikmatr@2001:470:69fc:105::a082)
2021-12-09 23:32:22 +0100asdofindia-m(~akshaymat@2001:470:69fc:105::831)
2021-12-09 23:32:22 +0100alexfmpe[m](~alexfmpem@2001:470:69fc:105::38ba)
2021-12-09 23:32:23 +0100ongy[m](~ongymatri@2001:470:69fc:105::5018)
2021-12-09 23:32:23 +0100jneira[m](~jneiramat@2001:470:69fc:105::d729)
2021-12-09 23:32:23 +0100Magnus[m](~magthetch@2001:470:69fc:105::d1a7)
2021-12-09 23:32:23 +0100siraben(~siraben@user/siraben)
2021-12-09 23:32:23 +0100Movedtosridoneem(~sridmatri@2001:470:69fc:105::1c2)
2021-12-09 23:32:23 +0100smichel17[m](~smichel17@2001:470:69fc:105::2d32)
2021-12-09 23:32:24 +0100SawyerBergeron[m(~sawyerber@2001:470:69fc:105::3036)
2021-12-09 23:32:24 +0100alex[m](~alexchete@2001:470:69fc:105::1:1001)
2021-12-09 23:32:24 +0100ManofLetters[m](~manoflett@2001:470:69fc:105::3be)
2021-12-09 23:32:24 +0100Tisoxin(~ikosit@user/ikosit)
2021-12-09 23:32:24 +0100carmysilna(~brightly-@2001:470:69fc:105::2190)
2021-12-09 23:32:24 +0100fendor[m](~fendormat@2001:470:69fc:105::fcbd)
2021-12-09 23:32:24 +0100aidy(~aidy@2001:470:69fc:105::c7b4)
2021-12-09 23:32:24 +0100DemiMarieObenour(~alwayscur@2001:470:69fc:105::4886)
2021-12-09 23:32:28 +0100 <hpc> anecdote along the same lines: i wanted to mess around with one of those quantum programming simulators
2021-12-09 23:32:37 +0100iammrinal0[m](~iammrinal@2001:470:69fc:105::1:2248)
2021-12-09 23:32:38 +0100 <monochrom> You know I'm telling the truth because every Haskell beginner begins by asking "so how do I say c=c+1"
2021-12-09 23:32:42 +0100 <hpc> i tried microsoft's Q# thing, ran into an endless parade of python issues
2021-12-09 23:32:50 +0100ocramz[m](~ocramzmat@2001:470:69fc:105::1:35b0)
2021-12-09 23:32:50 +0100TomasJakl[m](~jaklttchn@2001:470:69fc:105::a42)
2021-12-09 23:32:50 +0100ilkecan[m](~ilkecanma@2001:470:69fc:105::1:79b)
2021-12-09 23:32:50 +0100vaibhavsagar[m](~vaibhavsa@2001:470:69fc:105::ffe)
2021-12-09 23:32:50 +0100jmcantrell(~jmcantrel@user/jmcantrell)
2021-12-09 23:32:50 +0100maerwald[m](~maerwaldm@2001:470:69fc:105::1ee)
2021-12-09 23:32:52 +0100 <monochrom> micromanagement mentality right there.
2021-12-09 23:32:53 +0100 <hpc> then just finally went "screw it", switched to haskell
2021-12-09 23:32:57 +0100 <hpc> looked at the time first
2021-12-09 23:33:04 +0100jkachmar(~jkachmar@2001:470:69fc:105::c72d)
2021-12-09 23:33:09 +0100 <hpc> went to hackage, installed the first package i could find, wrote some code, built and ran it
2021-12-09 23:33:12 +0100 <hpc> done in under an hour
2021-12-09 23:33:16 +0100JoelMcCracken[m](~joelmccra@2001:470:69fc:105::8405)
2021-12-09 23:33:30 +0100RosarioPulella[m(~rosariopu@2001:470:69fc:105::a57)
2021-12-09 23:33:30 +0100puffnfresh[m](~puffnfres@2001:470:69fc:105::1:22da)
2021-12-09 23:33:40 +0100 <EvanR> c=c+1, 0=1, programmer gets a punishing shock from the type checker
2021-12-09 23:33:42 +0100TomWesterhout[m](~twesterho@2001:470:69fc:105::1:2918)
2021-12-09 23:33:42 +0100wildsebastian(~wildsebas@2001:470:69fc:105::1:14b1)
2021-12-09 23:33:42 +0100jinsun_(~jinsun@user/jinsun)
2021-12-09 23:33:57 +0100benjamin[m]1234(~benjaminm@2001:470:69fc:105::1:3f2f)
2021-12-09 23:34:09 +0100 <hpc> that's just refusing to approach the language on its own terms
2021-12-09 23:34:09 +0100acco[m](~accotedom@2001:470:69fc:105::1:3236)
2021-12-09 23:34:09 +0100surgeon[m](~surge9nma@2001:470:69fc:105::f585)
2021-12-09 23:34:09 +0100octeep[m](~octeepoct@2001:470:69fc:105::1:3dbf)
2021-12-09 23:34:09 +0100unrooted(~unrooted@2001:470:69fc:105::a4a)
2021-12-09 23:34:09 +0100inkbottle[m](~inkbottle@2001:470:69fc:105::2ff5)
2021-12-09 23:34:09 +0100tomku[m](~tomkumozi@2001:470:69fc:105::1:2fcb)
2021-12-09 23:34:09 +0100fcortesi(~fcortesi@2001:470:69fc:105::f3a9)
2021-12-09 23:34:10 +0100utk(~utk@2001:470:69fc:105::1:2fe0)
2021-12-09 23:34:21 +0100 <hpc> it's like writing
2021-12-09 23:34:22 +0100thedward[m](~thedwardm@2001:470:69fc:105::f79)
2021-12-09 23:34:22 +0100meatfeather[m](~meatfeath@2001:470:69fc:105::1:3311)
2021-12-09 23:34:29 +0100 <hpc> % putStrLn("abc")
2021-12-09 23:34:30 +0100 <yahb> hpc: abc
2021-12-09 23:34:34 +0100lambdandy[m](~lambdandy@2001:470:69fc:105::1:3045)
2021-12-09 23:34:34 +0100 <monochrom> BTW is it "micromanagement" as one word or is it 2 words "micro management"?
2021-12-09 23:34:34 +0100std_mutex[m](~stdmutexm@2001:470:69fc:105::1:4534)
2021-12-09 23:34:34 +0100InternetManaging(~imjmatrix@2001:470:69fc:105::1:2ea5)
2021-12-09 23:34:43 +0100monochrommicro-managers his language >:)
2021-12-09 23:34:45 +0100 <EvanR> it's one word
2021-12-09 23:34:46 +0100shiraeeshi[m](~shiraeesh@2001:470:69fc:105::1:77)
2021-12-09 23:34:46 +0100boxscape(~boxscape@user/boxscape)
2021-12-09 23:34:47 +0100 <hpc> or trying to find the lambdas in java, or the types in javascript
2021-12-09 23:34:51 +0100 <dsal> Lisp programmers are macromanagers
2021-12-09 23:34:56 +0100 <monochrom> hahaha
2021-12-09 23:34:59 +0100james[m]12(~jamesnina@2001:470:69fc:105::1:4203)
2021-12-09 23:35:05 +0100 <hpc> lol
2021-12-09 23:35:10 +0100 <monochrom> @remember dsal Lisp programmers are macromanagers
2021-12-09 23:35:10 +0100 <lambdabot> It is stored.
2021-12-09 23:35:11 +0100AlainJourez[m](~sherekahn@2001:470:69fc:105::1:4a71)
2021-12-09 23:35:24 +0100aveltras[m](~aveltrasm@2001:470:69fc:105::3ef9)
2021-12-09 23:35:25 +0100 <hpc> java programmers are SingletonManagers
2021-12-09 23:35:35 +0100 <dsal> A whole factory of them
2021-12-09 23:36:12 +0100dsalsuddenly wonders how many singleton factories there are
2021-12-09 23:37:00 +0100 <hpc> i searched for "singleton factory" and the first result is a stack overflow question, "singleton factories, good or bad?"
2021-12-09 23:37:09 +0100 <EvanR> a singleton factory sounds like a contradiction
2021-12-09 23:37:33 +0100 <monochrom> NFT factory
2021-12-09 23:38:31 +0100infinity0(~infinity0@occupy.ecodis.net) (Ping timeout: 268 seconds)
2021-12-09 23:39:39 +0100infinity0(~infinity0@occupy.ecodis.net)
2021-12-09 23:42:29 +0100 <kennyd> hpc, I'm pretty sure new java has lambda
2021-12-09 23:43:13 +0100 <hpc> sure, but everyone's going to be on 1.8 for at least the next 10 years :P
2021-12-09 23:43:16 +0100 <dsal> You probably have to give them really long names, though.
2021-12-09 23:43:25 +0100euandreh(~euandreh@2804:14c:33:9fe5:1b4:2cec:47c3:871e) (Ping timeout: 240 seconds)
2021-12-09 23:43:49 +0100deadmarshal(~deadmarsh@95.38.116.82)
2021-12-09 23:44:23 +0100 <kennyd> not bad! https://www.w3schools.com/java/java_lambda.asp
2021-12-09 23:44:57 +0100 <dsal> OMG. Is Java copying JavaScript now?
2021-12-09 23:46:21 +0100MatrixTravelerbo(~voyagert2@2001:470:69fc:105::22) (Quit: Client limit exceeded: 20000)
2021-12-09 23:46:28 +0100 <Pickchea> Hello! In the Hindley-Milner type system, the expression `\f.((g (f 0)) (f "foo")) (\x.x)' cannot be typed because `\x.x' would have to be monomorphic in order for the application inference rule to apply. This restriction exists because type inference in polymorphic lambda calculus is not decidable. But I can do that in Haskell and Haskell type inference in Haskell is decidable. So what gives?
2021-12-09 23:46:33 +0100siraben(~siraben@user/siraben) (Quit: Client limit exceeded: 20000)
2021-12-09 23:46:37 +0100MatrixTravelerbo(~voyagert2@2001:470:69fc:105::22)
2021-12-09 23:46:40 +0100puffnfresh[m](~puffnfres@2001:470:69fc:105::1:22da) (Quit: Client limit exceeded: 20000)
2021-12-09 23:46:42 +0100denbrahe[m](~denbrahem@2001:470:69fc:105::19c0) (Quit: Client limit exceeded: 20000)
2021-12-09 23:46:49 +0100kadoban(~kadoban@user/kadoban) (Quit: Client limit exceeded: 20000)
2021-12-09 23:46:52 +0100siraben(~siraben@user/siraben)
2021-12-09 23:46:54 +0100peddie(~peddie@2001:470:69fc:105::25d) (Quit: Client limit exceeded: 20000)
2021-12-09 23:46:58 +0100fgaz(~fgaz@2001:470:69fc:105::842) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:01 +0100 <hpc> :t \x -> x
2021-12-09 23:47:02 +0100 <lambdabot> p -> p
2021-12-09 23:47:04 +0100Arathorn(~arathorn@2001:470:69fc:105::1f) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:05 +0100puffnfresh[m](~puffnfres@2001:470:69fc:105::1:22da)
2021-12-09 23:47:06 +0100wildsebastian(~wildsebas@2001:470:69fc:105::1:14b1) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:10 +0100cdsmith(~cdsmithma@2001:470:69fc:105::284) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:16 +0100fgaz(~fgaz@2001:470:69fc:105::842)
2021-12-09 23:47:17 +0100kadoban(~kadoban@user/kadoban)
2021-12-09 23:47:20 +0100 <hpc> er, somehow i read that as \x -> x x
2021-12-09 23:47:21 +0100 <monochrom> You cannot do \f.((g (f 0)) (f "foo")) (\x.x) in Haskell either.
2021-12-09 23:47:27 +0100Tisoxin(~ikosit@user/ikosit) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:27 +0100InternetManaging(~imjmatrix@2001:470:69fc:105::1:2ea5) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:30 +0100peddie(~peddie@2001:470:69fc:105::25d)
2021-12-09 23:47:31 +0100denbrahe[m](~denbrahem@2001:470:69fc:105::19c0)
2021-12-09 23:47:31 +0100rednaZ[m](~r3dnazmat@2001:470:69fc:105::ba70) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:31 +0100ongy[m](~ongymatri@2001:470:69fc:105::5018) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:31 +0100cdsmith(~cdsmithma@2001:470:69fc:105::284)
2021-12-09 23:47:33 +0100Arathorn(~arathorn@2001:470:69fc:105::1f)
2021-12-09 23:47:33 +0100wildsebastian(~wildsebas@2001:470:69fc:105::1:14b1)
2021-12-09 23:47:33 +0100amesgen[m](~amesgenm]@2001:470:69fc:105::82b) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:33 +0100ericson2314(~ericson23@2001:470:69fc:105::70c) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:36 +0100the-coot[m](~the-cootm@2001:470:69fc:105::95f) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:36 +0100jophish(~jophish@2001:470:69fc:105::670) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:45 +0100unclechu(~unclechu@2001:470:69fc:105::354) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:47 +0100hsiktas[m](~hsiktasma@2001:470:69fc:105::30d4) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:48 +0100rednaZ[m](~r3dnazmat@2001:470:69fc:105::ba70)
2021-12-09 23:47:51 +0100unrooted(~unrooted@2001:470:69fc:105::a4a) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:56 +0100boxscape(~boxscape@user/boxscape) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:59 +0100maralorn(~maralorn@2001:470:69fc:105::251) (Quit: Client limit exceeded: 20000)
2021-12-09 23:47:59 +0100vaibhavsagar[m](~vaibhavsa@2001:470:69fc:105::ffe) (Quit: Client limit exceeded: 20000)
2021-12-09 23:48:00 +0100mc47(~mc47@xmonad/TheMC47) (Remote host closed the connection)
2021-12-09 23:48:02 +0100hsiktas[m](~hsiktasma@2001:470:69fc:105::30d4)
2021-12-09 23:48:08 +0100carmysilna(~brightly-@2001:470:69fc:105::2190) (Quit: Client limit exceeded: 20000)
2021-12-09 23:48:09 +0100zfnmxt(~zfnmxtzfn@2001:470:69fc:105::2b32) (Quit: Client limit exceeded: 20000)
2021-12-09 23:48:14 +0100ongy[m](~ongymatri@2001:470:69fc:105::5018)
2021-12-09 23:48:14 +0100quantum(~quantum@user/quantum/x-8556232) (Quit: Client limit exceeded: 20000)
2021-12-09 23:48:19 +0100tromp(~textual@dhcp-077-249-230-040.chello.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2021-12-09 23:48:25 +0100 <monochrom> What you can do, and this is right from HM again, is "let f = \x.x in ((g (f 0)) (f "foo"))". So, a "let" construct that polymorphizes "f = \x.x".
2021-12-09 23:48:29 +0100Tisoxin(~ikosit@user/ikosit)
2021-12-09 23:48:29 +0100Deide(~deide@user/deide) (Quit: Client limit exceeded: 20000)
2021-12-09 23:48:29 +0100bitonic(~bitonic@2001:470:69fc:105::1812) (Quit: Client limit exceeded: 20000)
2021-12-09 23:48:40 +0100amesgen[m](~amesgenm]@2001:470:69fc:105::82b)
2021-12-09 23:48:40 +0100smichel17[m](~smichel17@2001:470:69fc:105::2d32) (Quit: Client limit exceeded: 20000)
2021-12-09 23:48:43 +0100carmysilna(~brightly-@2001:470:69fc:105::2190)
2021-12-09 23:48:48 +0100 <hpc> wouldn't that work if the lambda was rank-2?
2021-12-09 23:48:53 +0100Artem[m](~artemtype@2001:470:69fc:105::75b) (Quit: Client limit exceeded: 20000)
2021-12-09 23:48:54 +0100the-coot[m](~the-cootm@2001:470:69fc:105::95f)
2021-12-09 23:48:54 +0100bitonic(~bitonic@2001:470:69fc:105::1812)
2021-12-09 23:48:57 +0100jchia[m](~jchiamatr@2001:470:69fc:105::c50b) (Quit: Client limit exceeded: 20000)
2021-12-09 23:48:58 +0100jmcantrell(~jmcantrel@user/jmcantrell) (Quit: Client limit exceeded: 20000)
2021-12-09 23:49:02 +0100zwro[m](~zwromatri@2001:470:69fc:105::1d4) (Quit: Client limit exceeded: 20000)
2021-12-09 23:49:03 +0100vaibhavsagar[m](~vaibhavsa@2001:470:69fc:105::ffe)
2021-12-09 23:49:07 +0100 <monochrom> Yes but you have to hand-write some type annotations.
2021-12-09 23:49:08 +0100zfnmxt(~zfnmxtzfn@2001:470:69fc:105::2b32)
2021-12-09 23:49:08 +0100jneira[m](~jneiramat@2001:470:69fc:105::d729) (Quit: Client limit exceeded: 20000)
2021-12-09 23:49:08 +0100 <hpc> (granted, that's haskell deviating from H-M)
2021-12-09 23:49:15 +0100jmcantrell(~jmcantrel@user/jmcantrell)
2021-12-09 23:49:21 +0100jchia[m](~jchiamatr@2001:470:69fc:105::c50b)
2021-12-09 23:49:22 +0100jophish(~jophish@2001:470:69fc:105::670)
2021-12-09 23:49:27 +0100surgeon[m](~surge9nma@2001:470:69fc:105::f585) (Quit: Client limit exceeded: 20000)
2021-12-09 23:49:29 +0100unrooted(~unrooted@2001:470:69fc:105::a4a)
2021-12-09 23:49:29 +0100InternetManaging(~imjmatrix@2001:470:69fc:105::1:2ea5)
2021-12-09 23:49:36 +0100Topik[m](~topikmatr@2001:470:69fc:105::a082) (Quit: Client limit exceeded: 20000)
2021-12-09 23:49:39 +0100ericson2314(~ericson23@2001:470:69fc:105::70c)
2021-12-09 23:49:39 +0100 <monochrom> Even in Haskell, you have to write at least "\(f :: forall a. a -> a)"
2021-12-09 23:49:40 +0100Christoph[m](~hpotsirhc@2001:470:69fc:105::2ff8) (Quit: Client limit exceeded: 20000)
2021-12-09 23:49:43 +0100boxscape(~boxscape@user/boxscape)
2021-12-09 23:49:45 +0100DemiMarieObenour(~alwayscur@2001:470:69fc:105::4886) (Quit: Client limit exceeded: 20000)
2021-12-09 23:49:53 +0100unclechu(~unclechu@2001:470:69fc:105::354)
2021-12-09 23:49:55 +0100jinsun_(~jinsun@user/jinsun) (Quit: Client limit exceeded: 20000)
2021-12-09 23:50:06 +0100alex[m](~alexchete@2001:470:69fc:105::1:1001) (Quit: Client limit exceeded: 20000)
2021-12-09 23:50:08 +0100maralorn(~maralorn@2001:470:69fc:105::251)
2021-12-09 23:50:12 +0100quantum(~quantum@user/quantum/x-8556232)
2021-12-09 23:50:13 +0100Deide(~deide@user/deide)
2021-12-09 23:50:16 +0100Ollie[m](~ollieocha@2001:470:69fc:105::41a5) (Quit: Client limit exceeded: 20000)
2021-12-09 23:50:17 +0100tomku[m](~tomkumozi@2001:470:69fc:105::1:2fcb) (Quit: Client limit exceeded: 20000)
2021-12-09 23:50:28 +0100Artem[m](~artemtype@2001:470:69fc:105::75b)
2021-12-09 23:50:34 +0100CiaoSen(~Jura@p200300c9570204002a3a4dfffe84dbd5.dip0.t-ipconnect.de)
2021-12-09 23:50:38 +0100ManofLetters[m](~manoflett@2001:470:69fc:105::3be) (Quit: Client limit exceeded: 20000)
2021-12-09 23:50:40 +0100Christoph[m](~hpotsirhc@2001:470:69fc:105::2ff8)
2021-12-09 23:50:40 +0100zwro[m](~zwromatri@2001:470:69fc:105::1d4)
2021-12-09 23:50:53 +0100Topik[m](~topikmatr@2001:470:69fc:105::a082)
2021-12-09 23:50:58 +0100deadmarshal(~deadmarsh@95.38.116.82) (Ping timeout: 260 seconds)
2021-12-09 23:50:59 +0100fendor[m](~fendormat@2001:470:69fc:105::fcbd) (Quit: Client limit exceeded: 20000)
2021-12-09 23:51:02 +0100SawyerBergeron[m(~sawyerber@2001:470:69fc:105::3036) (Quit: Client limit exceeded: 20000)
2021-12-09 23:51:02 +0100moats(~oats@user/oats) (Quit: Client limit exceeded: 20000)
2021-12-09 23:51:03 +0100alexfmpe[m](~alexfmpem@2001:470:69fc:105::38ba) (Quit: Client limit exceeded: 20000)
2021-12-09 23:51:05 +0100maerwald[m](~maerwaldm@2001:470:69fc:105::1ee) (Quit: Client limit exceeded: 20000)
2021-12-09 23:51:07 +0100jneira[m](~jneiramat@2001:470:69fc:105::d729)
2021-12-09 23:51:07 +0100smichel17[m](~smichel17@2001:470:69fc:105::2d32)
2021-12-09 23:51:07 +0100schuelermine[m](~schuelerm@user/schuelermine) (Quit: Client limit exceeded: 20000)
2021-12-09 23:51:19 +0100SawyerBergeron[m(~sawyerber@2001:470:69fc:105::3036)
2021-12-09 23:51:53 +0100geekosaurwonders how long before they do something about that "Client limit exceeded" error on the bridge
2021-12-09 23:52:01 +0100 <geekosaur> 20000 is clearly too small
2021-12-09 23:52:08 +0100utk(~utk@2001:470:69fc:105::1:2fe0) (Quit: Client limit exceeded: 20000)
2021-12-09 23:52:08 +0100moats(~oats@user/oats)
2021-12-09 23:52:10 +0100marinelli[m](~marinelli@2001:470:69fc:105::2d8) (Quit: Client limit exceeded: 20000)
2021-12-09 23:52:22 +0100Ollie[m](~ollieocha@2001:470:69fc:105::41a5)
2021-12-09 23:52:22 +0100 <EvanR> oof
2021-12-09 23:52:31 +0100Magnus[m](~magthetch@2001:470:69fc:105::d1a7) (Quit: Client limit exceeded: 20000)
2021-12-09 23:52:36 +0100marinelli[m](~marinelli@2001:470:69fc:105::2d8)
2021-12-09 23:52:36 +0100schuelermine[m](~schuelerm@user/schuelermine)
2021-12-09 23:52:36 +0100alexfmpe[m](~alexfmpem@2001:470:69fc:105::38ba)
2021-12-09 23:52:50 +0100Magnus[m](~magthetch@2001:470:69fc:105::d1a7)
2021-12-09 23:53:21 +0100 <hpc> wouldn't they have at least matched the limit they set on freenode?
2021-12-09 23:53:56 +0100 <geekosaur> presumably they did. but I gather a lot of folks switched to matrix to get a more modern ux
2021-12-09 23:54:24 +0100fcortesi(~fcortesi@2001:470:69fc:105::f3a9) (Quit: Client limit exceeded: 20000)
2021-12-09 23:54:32 +0100 <geekosaur> for example there was a fair amount of talk about #ghc switching to matrix, and discussing other folks who were doing so
2021-12-09 23:54:47 +0100 <hpc> ah
2021-12-09 23:54:51 +0100 <perro> I've never understsood matrix dev
2021-12-09 23:55:02 +0100 <Pickchea> monochrom, right, I actually can't do that in Haskell, I thought wrong!
2021-12-09 23:55:07 +0100 <perro> it's just never seemed consistent to me
2021-12-09 23:55:46 +0100 <mniip> (not on our side btw)
2021-12-09 23:55:57 +0100 <dsal> I've wanted to try matrix, but it seems like I either have to do a tremendous amount of work with a static IP address and stuff, or just like, use a different central service.
2021-12-09 23:55:59 +0100dsalmisses xmpp
2021-12-09 23:56:26 +0100 <perro> that's what I don't get. xmpp existed if you wanted to make a better system work off that
2021-12-09 23:56:30 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi) (Read error: Connection reset by peer)
2021-12-09 23:56:37 +0100 <perro> the bikeshedding ti has taken to get to where it is is like wow
2021-12-09 23:56:42 +0100Vajb(~Vajb@hag-jnsbng11-58c3a8-176.dhcp.inet.fi)
2021-12-09 23:57:10 +0100lavaman(~lavaman@98.38.249.169)
2021-12-09 23:57:14 +0100 <perro> it would be one thing if it was actually noticably superior and simpler but.... /me hushes
2021-12-09 23:58:06 +0100 <dsal> https://xkcd.com/927/
2021-12-09 23:58:54 +0100gehmehgeh(~user@user/gehmehgeh) (Quit: Leaving)
2021-12-09 23:59:38 +0100 <geekosaur> matrix fairly obviously wanted to be a better irc, not a different paradigm
2021-12-09 23:59:50 +0100 <geekosaur> although I guess this is -offtopic fodder