00:04:55 -!- pikhq has quit (Ping timeout: 244 seconds).
00:04:56 -!- pikhq_ has joined.
00:16:30 -!- pumpkin has joined.
00:19:24 -!- sebbu2 has quit (Quit: updating xchat-wdk).
00:19:56 -!- copumpkin has quit (Ping timeout: 248 seconds).
00:30:30 -!- lambdabot has joined.
00:41:54 <zzo38> The things about Dungeons&Dragons game, is that unlike chess and poker and so on, it is possible to solve situations that are impossible to solve.
00:54:00 -!- pikhq_ has quit (Ping timeout: 244 seconds).
00:59:22 -!- pikhq has joined.
01:02:44 <zzo38> http://hackage.haskell.org/package/barrier-monad
01:08:00 -!- DCliche has joined.
01:11:17 -!- Klisz has quit (Ping timeout: 252 seconds).
01:15:00 -!- pumpkin has changed nick to copumpkin.
01:24:03 -!- BeholdMyGlory has joined.
01:24:05 -!- BeholdMyGlory has left.
01:26:37 -!- sebbu has joined.
01:26:47 -!- kmc has quit (Quit: Leaving).
02:08:49 -!- Jafet has joined.
02:14:52 -!- pikhq_ has joined.
02:15:02 -!- pikhq has quit (Ping timeout: 244 seconds).
02:15:05 -!- copumpkin has quit (Ping timeout: 240 seconds).
02:23:13 -!- Darth_Cliche has joined.
02:25:07 -!- zzo38 has quit (Remote host closed the connection).
02:26:55 -!- DCliche has quit (Ping timeout: 244 seconds).
02:27:10 -!- itidus21 has changed nick to alloca_i32.
02:31:37 -!- alloca_i32 has changed nick to itidus21.
02:36:48 -!- copumpkin has joined.
03:07:23 <HackEgo> 2010-11-15.txt:18:29:06: <ais523_> (I'm aware of the US phone situation)
03:42:16 -!- zzo38 has joined.
04:10:32 <zzo38> I invented the D&D feat "Favored Mercy"; you have to select a creature type same as the ranger's favored enemy list and then there are various bonuses and restrictions that apply.
04:13:39 <zzo38> "Science Made Stupid: How to Discomprehend the World Around Us" by Tom Weller
04:14:26 <zzo38> "Cvltvre Made Stvpid: A Misguided Tour of Illiterature, Fine & Dandy Arts, & the Subhumanities" by Tom Weller
04:18:15 -!- azaq23 has joined.
04:38:05 <kallisti> does anyone no of a google API where I can grab timezone info?
04:38:13 <kallisti> equivalent to the "time in <location>" searched
04:40:07 -!- MDude has changed nick to MSleep.
04:59:56 <Sgeo> kallisti, update
05:01:57 <kallisti> pikhq_: can I ask tzinfo "time in anywhere, USA" and it will tell me the time?
05:03:32 <kallisti> I don't think it would work with small town names though
05:03:42 <kallisti> I'll just... do google searches and regex the time. :P
05:03:53 <pikhq_> You'd probably need a map for *that*.
05:04:08 <kallisti> (it's an IRC bot so dependence on a network connection isn't a problem)
05:04:27 <pikhq_> Also, that's bound to screw up: town name is ambiguous. :)
05:04:56 <pikhq_> Well, with state I *think* it might not be?
05:05:05 <kallisti> a reasonable person would provide a town, state combo
05:05:23 <kallisti> or a town, whateverelseyourcountrycallsthisshit, country
05:07:05 <kallisti> wow... boiling peanuts is rather time consuming.
05:07:11 <kallisti> suppose to boil them for like 24 hours.
05:09:12 <kallisti> hmmm, well, Google doesn't really make this easy.
05:09:24 <kallisti> maybe there XML api is better for this.
05:15:34 <zzo38> Do you know the sidereal time?
05:17:29 <kallisti> zzo38: yes it's 04:18 LST here
05:53:19 <itidus21> whateverelseyourcountrycallsthisshit
05:54:09 <kallisti> no town is a whateverelseyourcountrycallsthisshit town.
05:55:09 * kallisti has been boiling peanuts for over an hour now.
05:55:26 <itidus21> but then there is a town named Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch
05:56:13 <kallisti> oh look that's an actual thing.
05:56:49 <itidus21> Toponymy is the scientific study of place names (toponyms), their origins, meanings, use and typology. A toponymist is one who studies toponymy.
05:57:57 <kallisti> itidus21: The apple is the pomaceous fruit of the apple tree, species Malus domestica in the rose family (Rosaceae). It is one of the most widely cultivated tree fruits, and the most widely known of the many members of genus Malus that are used by humans. Apple grow on small, deciduous trees that blossom in the spring and produce fruit in the fall.
05:59:19 <kallisti> hmmm, these peanuts are still kind of crunchy.
06:02:33 <itidus21> A seminal experiment by Karen Wynn in 1992 involving Mickey Mouse dolls manipulated behind a screen demonstrated that five-month-old infants expect 1 + 1 to be 2, and they are comparatively surprised when a physical situation seems to imply that 1 + 1 is either 1 or 3.
06:03:10 <HackEgo> serate erilinst squcefingrata nridi sche dk feculaza le pres elatardia kan za ar sau rempanissidaroparinsilh tovigisallassa toncippilluce riedaiilloccau tfinan rous affiens feaatherroellyte rumqh sed em jelendcclocwted nut va acistophoroculvaliamangtola disses climan coo ebyted wity baniff hinosele proley widuchissirs forraseek oliterskiitcligitussies kr rapeosendon co pos lornfiernsident unalragewelsiegaus ze beffuringlatismen natschic bareng
06:03:22 <itidus21> after being taught the meanings of the Arabic numerals 0 through 4, one chimpanzee was able to compute the sum of two numerals without further training
06:07:48 <zzo38> kallisti: O, you do know the sidereal time. Do you know the moon declination?
06:09:51 -!- monqy has quit (Read error: Operation timed out).
06:12:04 <kallisti> zzo38: I actually just googled for the former. :P
06:12:17 <zzo38> Moon declination is -8 degrees 18 minutes
06:12:25 <zzo38> Sideral time is the right ascension of the zenith.
06:12:41 -!- monqy has joined.
06:13:07 -!- azaq23 has quit (Quit: Leaving.).
06:14:31 <kallisti> for a second that looked like leetspeak..
06:14:41 <kallisti> some weird way to say "same here"
06:15:00 <zzo38> Actually I meant 2 hour 33 minutes
06:17:28 <kallisti> awwww yeah boiled peanut time.
06:17:31 <kallisti> if you have never had boiled peanuts
06:17:35 <kallisti> I highly recommend that you do.
06:18:21 <zzo38> Do you know what right ascension and declination are? These are equatorial coordinates; do you know ecliptic coordinates?
06:22:44 <kallisti> I'm vaguely familiar with what an ecliptic is.
06:22:55 <kallisti> I can imagine that ecliptic coordinates are based on the ecliptic plane.
06:23:08 <zzo38> Yes, that is what it is.
06:24:32 <kallisti> and I'm guessing equatorial coordinates are based on the equator?
06:25:29 <zzo38> Hour angle can be used instead of right ascension. And you can use local hour angle or Greenwich hour angle.
06:26:00 <kallisti> but it's more or less expressing the same thing as right ascension, yes?
06:26:14 <zzo38> Yes, the difference is where the zero will be.
06:26:42 <kallisti> is hour angle in different units compared to right ascension?
06:27:12 <zzo38> Usually they are both given in units of hours, although you can use degrees instead.
06:28:38 <kallisti> ah so greenwich hour angle and right ascension are equivalently based on the prime meridian.
06:29:11 <zzo38> Right ascension has zero at the vernal equinox. Greenwich hour angle has zero at Greenwich.
06:29:26 <zzo38> Local hour angle is based on your location.
06:30:51 <kallisti> could be useful to know local hour angle if you're looking for celestial bodies in the sky.
06:31:00 <kallisti> is there any notion of local declination?
06:31:33 <zzo38> kallisti: Not as far as I know, but I was thinking about the same thing earlier today; you could have local declination too.
06:31:54 <kallisti> it would just be less convenient without GPS monitoring of some kind
06:32:07 <kallisti> with local hour angle you could go by your time zone instead of the precise longitude.
06:34:23 <kallisti> these poorly made boiled peanuts make me want some actual boiled peanuts.
06:34:38 <zzo38> You could, but timezones are only approximate. Using your precise longitude is better (you could find it in a city list if you have no GPS, and enter it into the computer, together with your latitude as well)
06:35:02 <zzo38> Of course city lists are more accurate than using timezones but still not perfectly accurate because the city is larger than one point.
06:35:24 <kallisti> I basically took some ripe shelled frozen peanuts and boiled them. you're supposed to take unripe peanuts with shells and boil them forever in salt water like peas.
06:35:43 <Sgeo> zzo38, is your barrier monad code up yet >.>
06:35:58 <zzo38> The package is called "barrier-monad"
06:36:48 <kallisti> I don't even know if they sell raw unripe peanuts.
06:37:17 <zzo38> Can you grow peanuts in your garden?
06:37:19 <kallisti> typically you buy boiled peanuts from stands. it's a popular thing in the deep south where peanuts are grown (especially Georgia and South Carolina)
06:37:23 -!- oerjan has joined.
06:37:34 <kallisti> well, depending on where you live
06:38:36 <kallisti> typically you buy boiled peanuts from stands. it's a popular thing in the deep south where peanuts are grown (especially Georgia and South Carolina)Peanuts grow best in light, sandy loam soil. They require five months of warm weather, and an annual rainfall of 500 to 1,000 mm (20 to 39 in) or the equivalent in irrigation water.
06:38:55 <kallisti> Peanuts grow best in light, sandy loam soil. They require five months of warm weather, and an annual rainfall of 500 to 1,000 mm (20 to 39 in) or the equivalent in irrigation water.
06:41:57 * oerjan recalls his mom grew tomatoes and cucumbers indoors, they needed buckets of water every day
06:42:35 <kallisti> that's because you live in a barren icy tundra.
06:42:37 <oerjan> well i'm sure there were tomatoes, i think there were cucumbers.
06:42:43 <oerjan> kallisti: close enough.
06:43:24 <kallisti> I'm pretty sure tomatos more or less grow themselves here.
06:43:32 <oerjan> i should point out this was still done in the summer, so they did get sunlight through the big glass door.
06:43:38 <kallisti> my parents have a tomato garden and I don't think I've seen them upkeep it very much.
06:44:43 <kallisti> also corn. wow, imagine that! plants that originate from the Americas grow well in the Americas!
06:44:52 <oerjan> well afair it was mostly the water.
06:45:31 <oerjan> the americas _are_ big you know, and especially in the north-south direction which temperatures vary along :P
06:46:09 <oerjan> and i vaguely think i read corn originated in the tropics.
06:46:22 <oerjan> incas or mayas or thereby
06:47:05 <kallisti> yes, but now we have like miles and miles of yellow corn being mass produced in the midwest
06:47:07 <oerjan> but i guess georgia is nearly tropical, isn't that were you were from
06:47:48 <pikhq_> oerjan: Not to mention we've got a lot of climactic changes from geography.
06:47:54 <kallisti> which means it's really hot in the summer, noticeably cold in the winter, and always humid.
06:47:55 <oerjan> i also guess they've probably bred varieties that need less heat
06:48:49 <kallisti> current humidity: 100% (it just rained a few hours ago :P)
06:48:51 <pikhq_> oerjan: Such breeding was lost to the mists of time; domesticated corn had already pretty well spread through the Americas.
06:49:07 <oerjan> most of my time the one time i was staying in the US was in Seattle, which probably does not fit that description. Boston did when i was there, though.
06:49:25 <kallisti> literally miles and miles of corn and soybeans.
06:50:03 <pikhq_> You've got grazing melding into corn fields... Over the course of several hundred miles.
06:50:20 <oerjan> pikhq_: yeah i just recently read that the original english settlers learned to grow corn
06:51:01 <zzo38> Mostly I know all this stuff about right ascension and ecliptic plane and that stuff due to looking at oerjan's "Agora Nomic's Horoscope" and I didn't know what "Node" is or what all these lines and numbers means, or what "Placidus houses" is; and then I downloaded Astrolog (and Daedalus, the author's other program) and it had a bunch of other features that I didn't understand,
06:51:10 <kallisti> oerjan: we learn about that shit in middle school history. :P
06:51:45 <oerjan> kallisti: i figure it is part of the thanksgiving lore
06:51:55 <kallisti> oerjan: but we don't learn any important history in middle school.
06:52:27 <zzo38> and I wondered why the sunrise/sunset times in this program are a bit off (I think it is because of refraction), and I figured out how to use it to calculate the date of Chinese New Year, and so on.
06:52:52 <kallisti> as far as I can tell Thanksgiving is basically "let's eat a bunch of stuff that's native to North America"
06:52:59 <oerjan> zzo38: well you definitely should know more than me already after all your experiments
06:53:16 <Sgeo> zzo38, I wrote this code to try to show off your Barrier monad, sorry if it's horrible and ugly and evil
06:53:16 <Sgeo> http://hpaste.org/54738
06:54:24 <oerjan> zzo38: i think i saw someone mention a monad essentially identical to the Barrier monad under a different name on some haskell forum recently. i've forgotten what the name was, though.
06:54:38 <oerjan> so it's not completely unknown
06:55:22 <zzo38> Sgeo: At least it works; I don't know if it is horrible and ugly and evil but it is a simple demonstration (simpler than many things you could do with this library)
06:56:11 <kallisti> zzo38: Sgeo: oh yes that is very analagous to Python coroutines.
06:56:16 <kallisti> I'm assuming more could be done though
06:56:24 <oerjan> i come to think of it, shouldn't there be a way to split the Barrier monad into two transformers, one for each part?
06:56:40 <Sgeo> kallisti, can you put yield into a function in Python and call that function and have it work sensibly?
06:56:57 <zzo38> oerjan: Yes, I thought of that someone else might have done similar things, anyways that happens a lot in mathematics (and programming in Haskell involves much about mathematics)
06:59:12 <kallisti> Sgeo: http://pastebin.com/j732vmzF
06:59:37 <kallisti> it's also possible to throw exceptions into a coroutine from other code.
06:59:58 <Sgeo> Not quite what I meant
07:00:07 <zzo38> oerjan: And yes I suppose I also know more about the Astrolog and what all that stuff means since I have used most of its features (except the biorhythms and the interpretation mode used for Agora; I don't care for those), and so on... I configured the file to use different defaults, such as degrees instead of zodiac signs, Campanus instead of Placidus, and so on
07:00:13 <Sgeo> As in, can you encapsulate complex yield code and use that in place of the yield keyword?
07:00:21 <Sgeo> To make a generator
07:00:59 <kallisti> well, calling the function produces the generator, with some plumbing it's possible but it's not implicit.
07:01:00 -!- Darth_Cliche has quit (Quit: You are now graced with my absence.).
07:01:32 <zzo38> I do know how generator functions work in JavaScript. Any function containing "yield" is a generator function, and it returns a Generator object when called (not doing anything yet). When you call the next or send methods of the generator function, it runs until yield, at which point the next or send method returns the value being yield and send(x) will cause the yield to x
07:01:39 <kallisti> for my MUD I was actually working on a menu system that maintained a stack of coroutines. when the top coroutine is exhausted it would pop off and go back to the previous one.
07:01:47 <oerjan> sheesh my nose tip got all scaly from blowing my nose
07:02:00 <oerjan> despite putting on lots of lotion
07:02:01 <kallisti> zzo38: yes that's how it works in Python
07:02:08 <kallisti> with the addition of a throw method that allows you to signal exceptions.
07:02:10 <zzo38> You could make it yourself without using yield; that is possible too (you simply need to return an object with the correct methods)
07:02:21 <zzo38> kallisti: JavaScript generator functions have that too.
07:03:14 <oerjan> Sgeo: i assume to work properly inside functions, yield needs to encapsulate a continuation
07:03:37 <kallisti> also menu coroutines could do things like manipulate the menu stack or defer to previous menu (without actually being consumed)
07:04:01 <kallisti> but essentially if the courtine yielded a new generate then the system pushed the new generator onto the stack, so it was fairly natural to write nested menu code.
07:04:02 <oerjan> but maybe not a completely arbitrary one
07:05:12 <kallisti> it was pretty neat, but I never actually finished the MUD codebase
07:05:18 <kallisti> mainly because I was doing pointless stuff like that.
07:06:18 <kallisti> in any case, it would be possible to abstract that sort of nested coroutine system into one coroutine.
07:06:55 <kallisti> the controller coroutine is the outside interface, and delegates input/output to the coroutines in the stack that it maintains.
07:08:32 <kallisti> can barrier monads do anything like that?
07:08:39 <oerjan> 05:17:29: <kallisti> zzo38: yes it's 04:18 LST here
07:08:43 <kallisti> I mean, in there current state.
07:09:19 <oerjan> apparently tunes also uses sidereal time.
07:09:22 <zzo38> I think the Haskell code using the library that I wrote, which is like the Python code example posted, would be like this: generate i = yield i >>= generate . maybe (succ i) id;
07:09:46 <zzo38> oerjan: Are you sure?
07:10:08 <oerjan> zzo38: it was a joke by the fact it was at almost the same minute, and tunes _does_ have a broken clock
07:10:38 <zzo38> kallisti: You probably can do something like that in Haskell somehow, using barrier monads, possibly using the BarrierT (the monad transformer for barrier monad)
07:10:53 <kallisti> zzo38: how does generate work?
07:11:23 <zzo38> kallisti: It is like the Python example code you posted: http://pastebin.com/j732vmzF
07:11:32 <kallisti> right but how does it actually work. :P
07:11:47 <Sgeo> Is crosstalk actually useful? >.>
07:12:06 <zzo38> Sgeo: I don't know but I think you suggested that to me isn' it?
07:12:13 <kallisti> zzo38: "help what is recursion"
07:12:23 <Sgeo> zzo38, I'm just wondering if what I suggested might be completely useless
07:13:01 <zzo38> Sgeo: Well, I don't know; maybe someone will find a use for it, either for computer programming or for mathematical use.
07:13:14 <kallisti> zzo38: I'm thinking an explicit stack is unecessary
07:13:34 <oerjan> 05:56:49: <itidus21> Toponymy is the scientific study of place names (toponyms), their origins, meanings, use and typology. A toponymist is one who studies toponymy.
07:13:37 <oerjan> 05:57:57: <kallisti> itidus21: The apple is the pomaceous fruit of the apple tree, species Malus domestica in the rose family (Rosaceae). It is one of the most widely cultivated tree fruits, and the most widely known of the many members of genus Malus that are used by humans. Apple grow on small, deciduous trees that blossom in the spring and produce fruit in the fall.
07:14:06 <kallisti> zzo38: maybe it just be handled with simple recursion?
07:14:07 <oerjan> incidentally, the city name Almaty originally means "father of the apple"
07:14:31 <zzo38> kallisti: Probably it can be done without an explicit stack; recursion probably works OK
07:15:58 <oerjan> oh wait it's apparently the older Alma-Ata form which means that
07:16:37 <oerjan> http://en.wikipedia.org/wiki/Almaty#Toponymy
07:17:04 <kallisti> f x = yieldSomeStuff >> (if someCondition then (>> f x) else id) barrier2
07:17:07 <zzo38> kallisti: Yes, you can use >> if you don't need the back values. Or whatever other values there are when using BarrierT with other monads too
07:18:33 <oerjan> (Almaty is still related to apples.)
07:18:36 <zzo38> Yes I suppose that is another way, too.
07:19:22 <oerjan> <kallisti> hmmm, these peanuts are still kind of crunchy. <-- WHY WOULD SOMEONE WANT NON-CRUNCHY PEANUTS, IT MAKES NO SENSE
07:19:34 <kallisti> oerjan: because they're boiled and thus soft and salty and delicious.
07:19:54 <oerjan> BUT BUT THEY'RE NOT _CRUNCHY_ SO IT'S ALL MEANINGLESS
07:20:04 <coppro> quintopia: I misread that in the obvious fashion.
07:20:37 <kallisti> like cashew (hahaha get it because it's not an actual nut?)
07:20:43 <oerjan> eek i have unleashed the american hordes
07:21:00 <kallisti> oerjan: boiled peanuts aren't even really a completely American thing.
07:21:18 <kallisti> I could probably tell a New Yorker to eat some boiled peanuts and they'd be like "wat"
07:21:26 <quintopia> but yeah dont knock it til youve tried it man
07:21:53 <kallisti> oerjan: it's just common in places where peanuts are grown. mainly in the south.
07:21:59 <quintopia> georgi is the peanut state. we get to decide what peanuts are best
07:22:20 <kallisti> we actually don't grow the kind of peanuts that are supposedly best for boiling
07:22:30 <kallisti> Valencia is supposed to be better than Runners. we grow Runners.
07:23:11 <kallisti> oerjan: eating boiled peanuts is kind of like... eating some kind of shellfish
07:23:20 <kallisti> but with peanut instead of fish meats.
07:23:21 <quintopia> i dont actually know anything about peanuts
07:23:31 <pikhq_> oerjan: Roasted is by far the more common thing in America.
07:23:33 <oerjan> oh well it's probably all that crazy mad scientist GWC's fault
07:24:12 <pikhq_> Peanut butter, fuck yeah.
07:24:18 <oerjan> he'd have invented more but he disappeared in his peanut oil powered time machine
07:24:30 <kallisti> oerjan: peanut oil is awesome btw
07:24:33 <quintopia> but the best mad food scientist is clearly robert c baker
07:25:32 <quintopia> kallisti: lets ship oerjan some boiled peanuts in a can. i know its not as good as fresh, but maybe it would be enough to sway him?
07:25:41 <kallisti> quintopia: it's a shame that oerjan probably doesn't know the joy of deep-fried chicken in peanut oil.
07:25:44 <oerjan> quintopia: sounds like a fowl guy
07:26:13 <quintopia> ill buy the can if youll cover shipping
07:26:36 <pikhq_> Incidentally, oerjan, "deep-fried *" is as American as you can get.
07:27:33 <oerjan> pikhq_: also scottish, i hear
07:28:07 <kallisti> quintopia: you've had chik-fil-a yes?
07:28:58 <kallisti> apparently they're like... common in many US states now.
07:29:34 <pikhq_> Some people have issues with funding anti-gay organisations, though.
07:29:57 <kallisti> pikhq_: I knew they were Christian based but not anti-gay
07:30:00 <oerjan> sometimes you have to think how many things we take for granted were actually invented by someone
07:30:20 <kallisti> I had never thought of it that way.
07:30:51 <pikhq_> kallisti: They're *American* Christian based. The only Christians in America that are in any way loud about it hate gay people so much. (and, of course, make regular trips to the nearest gloryhole)
07:31:40 * kallisti consults the yellow pages for the nearest gloryhole.
07:32:01 * kallisti googled for: gloryholes near Jasper, GA
07:32:01 <oerjan> sic transit gloria mundi
07:33:04 <kallisti> hmmm "glory hole rock shop" in Jasper, GA
07:33:37 <quintopia> kallisti: yes i have had chik-fil-a
07:37:17 <quintopia> also i hate their marketing dept forever
07:38:22 <quintopia> fuck no. mechanically separated chicken is
07:47:26 <pikhq_> "Sketchy" understates.
07:50:52 <Sgeo> kallisti, UPDOOT
08:02:43 -!- zzo38 has quit (Remote host closed the connection).
08:31:05 -!- GreaseMonkey has quit (Quit: The Other Game).
08:34:10 <oerjan> kallisti: just post the question to reddit.com/r/doesanybodyelse >:)
08:54:49 <lambdabot> Control.Concurrent forkIO :: IO () -> IO ThreadId
08:54:49 <lambdabot> GHC.Conc.Sync forkIO :: IO () -> IO ThreadId
08:54:49 <lambdabot> GHC.Conc forkIO :: IO () -> IO ThreadId
08:58:04 <kallisti> > forever . putStrLn $ "Hello, World!"
08:58:05 <lambdabot> Ambiguous type variable `b' in the constraint:
09:00:37 <oerjan> ah right, it's because of the ambiguous result type
09:00:46 <kallisti> oerjan: works fine in ghci though.
09:00:50 <oerjan> > forever . putStrLn $ "Hello, World!" :: IO ()
09:01:05 <kallisti> does ghci assume IO () or something?
09:01:13 <oerjan> kallisti: it's because ghci doesn't do a typeclass check on b
09:01:36 <oerjan> because it doesn't have a Show instance for IO
09:02:00 <oerjan> while lambdabot uses Typeable b => Show (IO b) in order to print that <IO ()> thing
09:03:03 <kallisti> oerjan: is there any standard type that doesn't derive Typeable
09:03:07 <oerjan> ghci just runs the action, and possibly prints the result with the right option set
09:03:11 <kallisti> specifically one that lambdabot exposes?
09:04:00 <kallisti> pretty much any type can derive typeable
09:04:07 <kallisti> so it would probably be hard to find.
09:04:28 <oerjan> kallisti: not if it has type arguments of kind not *
09:04:42 <oerjan> but you can still write a custom one then
09:05:02 <lambdabot> Source not found. My brain just exploded
09:05:06 <lambdabot> Data.Sequence index :: Seq a -> Int -> a
09:05:20 <oerjan> @hoogle Typeable a => a -> b
09:05:21 <lambdabot> Control.OldException throwDyn :: Typeable exception => exception -> b
09:05:22 <lambdabot> Unsafe.Coerce unsafeCoerce :: a -> b
09:05:22 <lambdabot> Data.Dynamic toDyn :: Typeable a => a -> Dynamic
09:06:12 <oerjan> > undefined :: IO (StateT IO Int)
09:06:13 <lambdabot> `Control.Monad.Trans.State.Lazy.StateT GHC.Types.IO GHC.Types.Int' is not a...
09:06:32 <oerjan> > undefined :: IO (StateT Int IO Int)
09:06:32 <lambdabot> No instance for (Data.Typeable.Typeable1
09:06:40 <oerjan> kallisti: well that's one
09:07:18 <kallisti> maybe it just doesn't have an instance?
09:07:25 <oerjan> as you see it has a * -> * argument, so cannot be derived, and nobody presumably bothered to make one
09:09:33 <oerjan> the new polymorphic kind extension will probably make it possible to derive any Typeable eventually
09:10:03 <oerjan> i've been thinking sometimes that for seems to be missing :P
09:10:22 <oerjan> it would just be flip map, presumably
09:10:49 <lambdabot> ["1","2","3","4","5","6","7","8","9","10"]
09:10:52 <kallisti> I am teh leet Python programmer
09:13:22 <kallisti> lambdabot: "no imperative programming allowed"
09:13:50 <oerjan> well you can use ST, i think
09:22:39 <kallisti> > let var = newSTRef; get = readSTRef; (*=) r n = modifySTRef r (*n); factorial n = runST $ do { x <- var 1; forM [1..n] (\i -> x *= i ); return (get x) } in factorial 5
09:22:39 <lambdabot> Inferred type is less polymorphic than expected
09:27:51 <fizzie> > let var = newSTRef; get = readSTRef; (*=) r n = modifySTRef r (*n); factorial n = runST $ do { x <- var 1; forM [1..n] (\i -> x *= i ); get x } in factorial 5
09:30:01 <kallisti> > let var = newSTRef; return = readSTRef; (*=) r n = modifySTRef r (*n); factorial n = runST $ do { x <- var 1; forM [1..n] (\i -> x *= i ); returm x } in factorial 5
09:30:06 <kallisti> > let var = newSTRef; return = readSTRef; (*=) r n = modifySTRef r (*n); factorial n = runST $ do { x <- var 1; forM [1..n] (\i -> x *= i ); return x } in factorial 5
09:30:20 <kallisti> probably the most elegant way to write factorial.
09:31:05 <kallisti> as a Python coder writing Haskell, I find that forM [1..n] (x *=) is a tad unreadable
09:31:48 <fizzie> As a corollary to "most elegant way to write factorial",
09:31:50 <fizzie> > let var = newSTRef; return = readSTRef; bestIdEver x = runST $ do { y <- var x; return y } in bestIdEver 42
09:34:04 <kallisti> of course a real Haskell programmer never leaves ST
09:34:16 <fizzie> If only (x *= ◌) were the same thing as (x *=), then it'd make sense; x *= the hole.
09:34:22 <kallisti> so really we should omit the runST and simply pass in STRefs
09:35:37 <kallisti> well, actually just omit the runST
09:35:50 <kallisti> passing STRefs would be if you want pass-by-reference
09:41:44 <kallisti> oerjan: fizzie: would be nice to have a Ref typeclass with the var function
09:41:50 <kallisti> instance Ref IO IORef where var = newIORef
09:42:18 <kallisti> though I think I like the name ref better.
09:42:39 <Sgeo> Why are some things called Refs and others called Vars?
09:43:02 <kallisti> variable implies a syntactical feature
09:43:46 <kallisti> x is the variable. YOu access via the syntax of the programming language, simply by writing its name.
09:44:10 <fizzie> An MVar is not any more syntactic than an IORef though.
09:44:15 <Sgeo> That's great, except it doesn't explain why Haskell has MVars and TVars
09:44:30 <kallisti> dunno. different people write different code? :P
09:44:38 <fizzie> "MRef" sounds too much like a dog barking?
09:48:09 <kallisti> I wonder if anyone actually uses ST
09:49:26 <fizzie> It's funny how the descriptions of IORef and STRef both use the word "variable" ("A mutable variable in the IO monad", "a mutable variable in state thread") while neither of the descriptions for MVar and TVar do ("mutable location", "Shared memory locations").
09:49:53 <kallisti> it would be better if MVar and TVar said "reference"
09:55:51 -!- oerjan has quit (Quit: leaving).
10:32:00 <kallisti> > deriv (\x -> x*sin(X^2 + 1)) 5
10:32:00 <lambdabot> Not in scope: data constructor `X'
10:32:05 <kallisti> > deriv (\x -> x*sin(x^2 + 1)) 5
10:32:23 <kallisti> > deriv (\x -> x*sin(x^2 + 1)) (x :: Expr)
10:32:23 <lambdabot> 1 * sin (x * x + 1) + x * ((1 * x + x * 1) * cos (x * x + 1))
10:33:10 <kallisti> if only it reduced properly...
10:41:49 <Sgeo> Maybe == should just be undefined
10:42:09 <Sgeo> Ords of genius.
10:43:36 <kallisti> Sgeo: well it kind of can't make sense unless Expr is demonstrating a particular kind of Num instance.
10:44:03 <kallisti> if all Num instances were fields, you could make a number of reductions that make two Exprs with different textual representations equivalent.
10:44:39 <Sgeo> Huh, didn't think about that
10:48:50 <kallisti> but unless you do some pretty complicated symbolic reasoning you're not really going to get an Eq instance that comes anywhere close to basically determine if two arbitrary expressions are equal.
10:49:10 <kallisti> under the assumption that the Num instance that Expr is representing behaves like real numbers.
10:51:23 -!- monqy has quit (Quit: hello).
10:59:45 <lambdabot> forall source. (Extract source) => (Int, Int) -> source -> source
10:59:52 -!- ais523 has joined.
11:05:28 -!- ais523 has quit (Ping timeout: 258 seconds).
11:06:04 -!- ais523 has joined.
11:06:05 -!- ais523 has quit (Changing host).
11:06:05 -!- ais523 has joined.
11:08:20 <lambdabot> ["<<<","<<>","<<=","<><","<>>","<>=","<=<","<=>","<==","><<","><>","><=",">...
11:08:24 <fizzie> They should have all of those.
11:09:05 <fizzie> ["<<<","<<>","<<=","<><","<>>","<>=","<=<","<=>","<==","><<","><>","><=",">><",">>>",">>=",">=<",">=>",">==","=<<","=<>","=<=","=><","=>>","=>=","==<","==>","==="] -- that's not such a long list. And I'm sure they can figure out some meanings for everyone.
11:09:21 <fizzie> For example <>< could make some fish swim across the screen.
11:14:35 <fizzie> ><> makes the fishes go the other way.
11:15:28 <lambdabot> forall a b. (Num a, Num b) => (Dif a -> Dif b) -> a -> b
11:15:34 <kallisti> I'm confused as to where this function comes from
11:15:38 <kallisti> I can't find it anywhere on the interwebs
11:18:05 <fizzie> http://hackage.haskell.org/packages/archive/numbers/2009.8.9/doc/html/Data-Number-Dif.html ?
11:22:52 <Deewiant> ( http://holumbus.fh-wedel.de/hayoo/hayoo.html?query=%28Dif%20a%20-%3E%20Dif%20b%29%20-%3E%20a%20-%3E%20b )
11:29:28 <ais523> <<= and =<< are from Feather
11:29:48 <ais523> retroactive and proactive assignment, respectively
11:30:03 <ais523> (proactive assignment does nothing right now, but controls when in time a retroactive assignment happens)
11:34:04 <fizzie> >, ≫, ⋙; greater-than, much greater-than, very much greater-than; sadly I think that's where they gave up. (Though there is ⫸, the triple nested greater-than.)
11:35:17 <fizzie> Certainly there would have been more intensifiers to go with. Really very much greater-than, honestly really very much greater-than, I'm not even kidding how much greater-than, etc.
11:35:22 <kallisti> > iterate df (sin (dVar pi :: Dif Expr))
11:35:23 <lambdabot> [sin pi~~,1 * cos pi~~,1 * (1 * negate (sin pi))~~,1 * (1 * (1 * negate (co...
11:35:40 <kallisti> > map val $ iterate df (sin (dVar pi :: Dif Expr))
11:35:41 <lambdabot> [sin pi,1 * cos pi,1 * (1 * negate (sin pi)),1 * (1 * (1 * negate (cos pi))...
11:36:12 <kallisti> the value, first derivative, second derivative, etc
11:37:15 -!- Phantom_Hoover has joined.
11:39:36 <kallisti> > map val $ iterate df (sin (dVar x))
11:39:37 <lambdabot> [sin x,1 * cos x,1 * (1 * negate (sin x)),1 * (1 * (1 * negate (cos x))),1 ...
11:43:04 <kallisti> > let y = dVar x in map val $ iterate df (x^3 + x^2 + x + 5)
11:43:05 <lambdabot> Couldn't match expected type `Data.Number.Dif.Dif a'
11:43:18 <fizzie> It would be better if it printed [sin x,cos x,negate (sin x),negate (cos x),sin x,cos x,even you,should be,able to,figure it,out by,now,...]
11:43:25 <kallisti> > let loly = dVar x in map val $ iterate df (x^3 + x^2 + x + 5)
11:43:26 <lambdabot> Couldn't match expected type `Data.Number.Dif.Dif a'
11:43:48 <kallisti> I HAVE TALKED ABOUT THIS PREVIOUSLY
11:44:03 <ais523> > (sin x * sin x) + (cos x * cos x)
11:44:08 <fizzie> About making the bot more of an asshole? Yes, I think it would fit in better here.
11:44:30 <ais523> > deriv (\a -> (sin a * sin a) + (cos a * cos a)) x
11:44:31 <lambdabot> 1 * cos x * sin x + sin x * (1 * cos x) + (1 * negate (sin x) * cos x + cos...
11:44:58 <kallisti> > let y = dVar x in map val $ iterate df (y^3 + y^2 + y + 5)
11:44:59 <lambdabot> [x * x * x + x * x + x + 5,(1 * x + x * 1) * x + x * x * 1 + (1 * x + x * 1...
11:45:17 <kallisti> > let y = dVar x in map val $ iterate df (y^2 + y + 5)
11:45:18 <lambdabot> [x * x + x + 5,1 * x + x * 1 + 1,1 * 1 + 1 * 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,...
11:49:00 <fizzie> All those are so begging for a Mathematica FullSimplify[].
11:49:09 <fizzie> Or "FoolSimplify", as we tend to call it.
11:50:03 <kallisti> :t let nDerivs f x = succ . length . takeWhile (/= 0) . iterate df $ (f (dVar x)) = dVar x in nDerivs
11:50:11 <kallisti> :t let nDerivs f x = succ . length . takeWhile (/= 0) . iterate df $ (f (dVar x)) in nDerivs
11:50:12 <lambdabot> forall a a1. (Num a, Num a1) => (Dif a -> Dif a1) -> a -> Int
11:50:35 <kallisti> :t let nDerivs f x = succ . length . takeWhile (/= 0) . iterate df $ (f (dVar x)) in nDerivs (\x -> x^2)
11:50:42 <kallisti> > let nDerivs f x = succ . length . takeWhile (/= 0) . iterate df $ (f (dVar x)) in nDerivs (\x -> x^2)
11:50:45 <lambdabot> Overlapping instances for GHC.Show.Show (a -> GHC.Types.Int)
11:51:03 <kallisti> > let nDerivs f x = succ . length . takeWhile (/= 0) . iterate df $ (f (dVar x)) in nDerivs (\x -> x^2) 5
11:51:10 <kallisti> > let nDerivs f x = succ . length . takeWhile (/= 0) . iterate df $ (f (dVar x)) in nDerivs (\x -> x^2) 0
11:51:19 <kallisti> so it might not be accurate when you pass 0 :P
11:51:39 <kallisti> > let nDerivs f x = succ . length . takeWhile (/= 0) . iterate df $ (f (dVar x)) in nDerivs (\x -> x^2) 1
11:52:49 <kallisti> > let nDerivs f = succ . length . takeWhile (/= 0) . iterate df $ (f (dVar x)) in nDerivs (\x -> x^2)
11:53:00 <kallisti> @let nDerivs f = succ . length . takeWhile (/= 0) . iterate df $ (f (dVar x))
11:55:13 <kallisti> > iterate df (const 1 (dVar x))
11:55:14 <lambdabot> [1~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~...
11:55:39 <kallisti> right, I want it to count the first 0.
11:58:37 <lambdabot> help <command>. Ask for help for <command>. Try 'list' for all commands
11:58:50 <lambdabot> undefine. Reset evaluator local bindings
11:59:15 <kallisti> @let nDerivs f = length . takeWhile (/= 0) . iterate df $ (f (dVar x))
12:15:06 <lambdabot> Overlapping instances for GHC.Show.Show (m -> m -> m)
12:15:12 <lambdabot> forall m. (Monoid m) => m -> m -> m
12:15:27 <lambdabot> forall a. (Num a) => (Dif Expr -> Dif a) -> Int
12:17:39 -!- Patashu has quit (Quit: MSN: Patashu@hotmail.com , Gmail: Patashu0@gmail.com , AIM: Patashu0 , YIM: patashu2 , Skype: patashu0 .).
12:24:12 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
12:40:12 -!- Phantom_Hoover has joined.
13:02:08 -!- zzo38 has joined.
13:06:44 -!- boily has joined.
13:12:12 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
13:13:42 -!- Patashu has joined.
13:13:52 <Patashu> I'm staying up to solve this http://www.canyoucrackit.co.uk/15b436de1f9107f3778aad525e5d0b20.js my life is interesting
13:14:35 -!- Taneb has joined.
13:23:02 -!- Phantom_Hoover has joined.
13:37:14 -!- Patashu has quit (Quit: MSN: Patashu@hotmail.com , Gmail: Patashu0@gmail.com , AIM: Patashu0 , YIM: patashu2 , Skype: patashu0 .).
13:37:24 -!- Phantom_Hoover has quit (Ping timeout: 244 seconds).
13:48:27 <Taneb> How are you, boily?
13:50:38 -!- Phantom_Hoover has joined.
13:51:28 <Taneb> Hello, Phantom_Hoover
13:58:18 -!- ais523 has quit (Ping timeout: 244 seconds).
13:58:49 -!- ais523 has joined.
14:08:31 <zzo38> Once, I was in a hotel, they required keycards for the elevator but I didn't have any so I went to the top floor by stairs and knocked on the door (it is my hotel room, but some other people too, and they had the keycard). And if any hotel has elevator that requires a keycard and then you only go to your floor, then it makes it less secure than one that does not require a keycard
14:12:30 <Taneb> Once, I was in a hotel, booked under the name of "random"
14:16:12 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
14:24:16 <fizzie> Quite often the doors in the stairwell that lead to the actual floors also require a keycard.
14:26:13 <fizzie> Once I worked at a place where you would get trapped in the stairwell if you forgot your card; the door from the offices to the stairs could be opened with a button from the inside, but the exit door at the bottom required a card always. I have a vague feeling that's against all kinds of emergency exit rules and whatnot.
14:26:54 <fizzie> Normally those things are always constructed so that if you forget the key, you can at least exit the building.
14:27:08 <fizzie> (And then freeze to death outside, but that's not relevant.)
14:27:46 <zzo38> In the place I was in, a keycard was not required to open the doors in the stairwell.
14:29:03 -!- Phantom_Hoover has joined.
14:48:19 <Gregor> lambdabot: Any spammy, useless messages for me?
14:49:53 <Taneb> Dungeons of Dredmor just crashed
14:51:18 <fizzie> Does it print out "Suddenly, the dungeon collapses" too?
15:03:30 <zzo38> Why can I not access this? http://www.freesoftwaremagazine.com/articles/encouraging_next_generation_hackers_part_1_raspberry_pi_25_computer
15:12:26 <Taneb> And maybe, what do they look like?
15:12:29 <Vorpal> Taneb: if so there is a patch to the data files that might help (helped for me). Let me find the link
15:13:36 <Vorpal> Taneb: http://community.gaslampgames.com/threads/statue-of-inconsequentia-crash.1318/ (for me it happened when changing dungeon level)
15:13:59 <Vorpal> there is a patch a bit down
15:14:38 <Vorpal> <fizzie> Does it print out "Suddenly, the dungeon collapses" too? <-- for me it just plain segfaulted
15:30:24 <kallisti> wow I apparently didn't have the network package installed.
15:30:28 <kallisti> shows you how much Haskell I've been programming..
15:31:08 <kallisti> hmmm, I still get these really weird linker errors from importing Network.Socket
15:36:24 <kallisti> does anyone else find Network.Socket a little cumbersome?
15:38:26 <Taneb> Can't find the install directory..
15:39:28 -!- copumpkin has quit (Quit: Leaving...).
15:39:37 -!- copumpkin has joined.
15:45:14 <ais523> "Shopping for a Dyson DC25 Ball All-Floors Upright Vacuum Cleaner might not appear like a big deal, however it does require a bit of planning."
15:45:54 <ais523> aha: "Probably you aspire to realize what is certainly my favourite [http://google.com internet search engine]."
15:46:00 <ais523> the spambots spamming Google are back again
15:46:33 <ais523> (as in, advertising Google)
16:03:47 -!- Taneb has quit (Quit: Leaving).
16:12:25 -!- elliott has joined.
16:13:04 <elliott> 22:22:05: <ais523> <mikehart> Just noticed my email in my account settings was 0.034064395384923 I asume that was the issue.
16:13:21 <ais523> elliott: the phpBB gone mad
16:13:35 * elliott tries to figure out how that could possibly work
16:13:43 <ais523> where it changed all the posts into md5 hashes, it apparently changed email addresses into (double-precision, by the look of it) floating point numbers
16:14:05 <ais523> (it's unclear what they're md5 hashes /of/, btw; kind-of hard to reverse them)
16:14:13 <elliott> did you try googling them?
16:14:19 <ais523> I picked one at random, no results
16:14:22 <ais523> I didn't google any others
16:15:38 <coppro> why did I get an email sent to all employees
16:15:50 -!- derrik has joined.
16:16:10 <elliott> perhaps you are an employee
16:16:47 -!- Slereah has joined.
16:18:17 -!- Slereah_ has quit (Ping timeout: 240 seconds).
16:18:27 <ais523> sending an email to all employees would be impressive
16:18:38 <ais523> almost like sending an email to every internet user, just slightly less global
16:18:38 <coppro> elliott: No, I pay them.
16:18:56 <ais523> presumably sending an email to absolutely everyone would be the easiest way to accomplish an "email-all-employees" requirement
16:19:00 <coppro> (them being the university)
16:19:30 <elliott> ais523: that would be fun to try
16:22:29 <coppro> ais523: You'd also need to get them all email addresses
16:22:47 <ais523> coppro: that's trivial
16:22:54 <ais523> sending them their logins would be the hard part
16:23:27 <coppro> ais523: Why not just make an email address for everyone?
16:23:53 <lambdabot> "hihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihi...
16:23:54 <ais523> coppro: that's what I was implying
16:24:05 <elliott> hmm, github's language detection is rather imperfect
16:24:10 <ais523> the hard part being, giving everyone access to their account
16:24:21 <elliott> ais523: just let everyone access every account
16:24:29 <Vorpal> glClear(GL_COLOR_BUFFER_BIT);
16:24:33 <Vorpal> this seems so very wrong
16:24:36 <ais523> elliott: then how is it an account specific to the person?
16:24:46 <ais523> Vorpal: awesome, please give more context
16:24:48 <elliott> ais523: nobody would stop calling <webmail service> personal email just because there's a backdoor!
16:24:56 <Vorpal> ais523: can't. Darwinia source code.
16:24:57 <elliott> ais523: they might claim it's a /bad/ personal email service, though
16:25:03 <ais523> Vorpal: err, not in the code itself
16:25:13 <ais523> but as to why that's written
16:25:29 <ais523> (I'm guessing that there's some sort of OpenGL/Direct3D wrapper that can call either, and is based on OpenGL function names)
16:25:38 <Vorpal> elliott: anyway I gave up getting darwinia to compile... Linux implementation files are way out of date with shared headers (like when there is foo_win.cpp and foo_sdl.cpp)
16:25:47 <Vorpal> <ais523> but as to why that's written <-- don't know yet
16:26:02 <elliott> Vorpal: I bet AII compiles perfectly on Linux.
16:26:14 <Vorpal> elliott: give me the source right now then
16:26:27 <elliott> Vorpal: Nobody can do that; light speed, dude.
16:26:38 <Vorpal> elliott: well within 10 minutes
16:26:41 <elliott> You can't even access Darwinia's code instantly.
16:26:44 <kallisti> > let fixify f = fix . f; repeat = fixify (:); cycle = fixify (++); forever = fixify (>>) in fixify
16:26:45 <lambdabot> Overlapping instances for GHC.Show.Show (f (a -> a) -> f a)
16:26:49 <kallisti> :t let fixify f = fix . f; repeat = fixify (:); cycle = fixify (++); forever = fixify (>>) in fixify
16:26:50 <lambdabot> forall (f :: * -> *) a. (Functor f) => f (a -> a) -> f a
16:26:57 <elliott> Vorpal: What, so if it's bigger than you can download in 10 minutes it doesn't count?
16:27:23 <Vorpal> elliott: no to the start of downloading. I expect the rest within at most a few days
16:27:30 <Vorpal> anything more is just silly
16:27:43 <elliott> Vorpal: I refuse to let my reputation depend on the reliability of your internet connection
16:27:55 <kallisti> @hoogle (Functor f) => f (a -> a)
16:27:55 <lambdabot> Data.Generics.Schemes everywhereBut :: GenericQ Bool -> GenericT -> GenericT
16:27:55 <lambdabot> Data.Generics.Aliases unGQ :: GenericQ' r -> GenericQ r
16:27:55 <lambdabot> Data.Generics.Twins gzipWithT :: GenericQ (GenericT) -> GenericQ (GenericT)
16:28:14 <elliott> Functor provides no way to get an f a for any a
16:28:24 <elliott> without already having an f b and a (b -> a), ofc
16:28:29 <lambdabot> forall a (f :: * -> *). (Applicative f) => f (a -> a)
16:29:57 <kallisti> elliott: well obviously it's not unpossible because I just used 3 functions that satisfy that type. I assume you mean it's impossible to generally do that.
16:30:28 <Vorpal> ais523: there seem to be no such wrappers
16:30:33 <elliott> there is no value foo :: (Functor f) => f (a -> a)
16:30:35 <kallisti> I was hoogling for functions I could fixify as above.
16:30:38 <Vorpal> ais523: it just makes no sense
16:30:42 <ais523> Vorpal: they'd probably be in a third-party library
16:30:44 <elliott> your type was (Functor f) => f (a -> a) -> f a
16:30:50 <Vorpal> ais523: well I looked in lib/
16:30:56 <ais523> it could be a typo for ifndef, I guess
16:31:01 <elliott> kallisti: anyway, that's just because lambdabot (.) = fmap
16:31:17 <ais523> but I doubt it, or the d3d version wouldn't even compile with the typo in, so it'd have been caught easily
16:31:32 <elliott> Vorpal: um, maybe the Direct3D version just uses OpenGL for some things?
16:31:53 <kallisti> :t let fixify f = fix Prelude.. f; repeat = fixify (:); cycle = fixify (++); forever = fixify (>>) in fixify
16:31:54 <lambdabot> forall a a1. (a -> a1 -> a1) -> a -> a1
16:31:58 <elliott> ais523: arguable, considering the code doesn't compile on linux in the first place
16:32:01 <Vorpal> elliott: maaybe. But I'm pretty sure that mixing them is in general a bad idea and unlikely to work
16:32:16 <ais523> elliott: it'd have happened on every platform, unless that bit's Linux-specific too
16:32:24 <kallisti> @@ @hoogle @type let fixify f = fix Prelude.. f; repeat = fixify (:); cycle = fixify (++); forever = fixify (>>) in fixify
16:32:25 <lambdabot> Data.IntMap fold :: (a -> b -> b) -> b -> IntMap a -> b
16:32:26 <lambdabot> Data.IntMap foldr :: (a -> b -> b) -> b -> IntMap a -> b
16:32:26 <lambdabot> Data.IntMap foldr' :: (a -> b -> b) -> b -> IntMap a -> b
16:32:33 <elliott> ais523: USE_DIRECT3D would not be set on Linux
16:32:43 <Vorpal> elliott: it was in the classical software raytrace loading screen of darwinia
16:32:46 <elliott> ais523: I'm just saying that the code obviously has errors not in the released binaries for whatever reason
16:32:46 <Vorpal> if you remember that one
16:34:07 <ais523> what does seq do, and is it something incredibly unhaskellish?
16:34:24 -!- derrik has quit (Quit: reconnect).
16:34:29 <kallisti> ais523: it's kind of unhaskellish?
16:34:33 <elliott> either that, or are on a campaign to wilfully forget as much Haskell as possible :P
16:34:40 <ais523> elliott: well, the obvious meaning is "force a and return b"
16:34:41 <elliott> ais523: seq _|_ a = _|_; seq a b = b
16:34:57 <elliott> it does break parametricity a bit though
16:34:59 -!- derrik has joined.
16:35:09 <ais523> I was thinking "a can't possibly have a side effect, so how would seq be different from flip const"
16:35:20 <ais523> and the answer is that it's an infinite-loop-checker?
16:35:23 <kallisti> it does have a side effect of sorts.
16:35:35 <ais523> now I'm just trying to work out why it'd be useful
16:35:41 <elliott> ais523: it's not an infinite loop checker
16:35:45 <elliott> ais523: it's _|_ if either argument is bottom
16:36:01 <kallisti> elliott: forcing the evaluation of a thunk is pretty side-effecty
16:36:07 <ais523> well, bottom = infinite loop or exception
16:36:07 <elliott> kallisti: there are no thunks
16:36:16 <elliott> kallisti: by that definition, beta-reduction is a side-effect
16:36:22 <elliott> because it mutates the thunk in many implementations
16:37:55 <elliott> ais523: anyway, it's useful because seq is strict in both of its arguments
16:37:58 <kallisti> elliott: well it forces a in a context where it would not normally be forced.
16:38:04 <elliott> as opposed to flip const, which is strict in only its latter
16:38:12 <elliott> kallisti: "not normally"? plenty of functions are strict in both their arguments
16:38:17 <elliott> seq is just the only polymorphic one
16:38:18 <ais523> elliott: oh, so in practice it makes the code run faster by being strict?
16:38:22 <kallisti> elliott: yes, those functions do things to their arguments
16:38:26 <ais523> (strictness doesn't always speed up code, but can do in some contexts)
16:38:26 <kallisti> elliott: seq only "does things" to one of them.
16:38:34 <elliott> ais523: that's why you would use it, yes
16:38:41 <elliott> ais523: it's a common misconception that seq must evaluate its first argument first
16:38:44 <elliott> but that's not guaranteed at all
16:38:47 <elliott> GHC provides pseq for that purpose
16:39:04 <ais523> elliott: it can evaluate the second argument, then the first, then return the second, I guess
16:39:06 <elliott> (some people think it /should/ guarantee that, but that breaks even more properties :))
16:39:13 <ais523> and that's the only other possible evaluation order
16:39:13 <elliott> ais523: indeed. and GHC sometimes _does_ do this.
16:39:21 <elliott> kallisti: wrong; id is strict in its argument too
16:39:35 <elliott> seq "does the same thing| to both its arguments
16:39:43 <elliott> i'm not being purposefully dense, you're just wrong
16:40:13 <kallisti> elliott: under normal Haskell semantics, if you accept two arguments and return the second one, the first one is never evaluated
16:40:31 <kallisti> elliott: id is irrelevant because it returns its one argument
16:40:42 <elliott> kallisti: actually no, the first one could be evaluated too. but you are still wrong even ignoring that:
16:40:50 <elliott> all you are saying is that (\a b -> b) is not strict in its first argument
16:40:58 <elliott> because that is the only such function that meets your criteria
16:41:05 <elliott> but nobody claimed seq was like (\a b -> b) "but special"
16:41:22 <elliott> also, "doing something special" is not a side-effect.
16:42:07 <lambdabot> Source not found. You untyped fool!
16:43:36 <ais523> elliott: is there any observable difference between id being strict and id being lazy?
16:43:39 <kallisti> help where's the part where seq only uses un-side-effectful Haskell code to do what it does.
16:43:43 <elliott> ais523: id can't possibly be lazy
16:43:56 <elliott> kallisti: similarly, (+) on Int has side-effects, because you can't implement it in Haskell
16:44:05 <elliott> EVERY PRIMITIVE HAS SIDE-EFFECTS!
16:44:11 <ais523> elliott: well, lazy id would do the say thing as strict id, right down to evaluation order
16:44:12 <elliott> Turns out Haskell is impure because kallisti is an idiot.
16:44:18 <kallisti> elliott: that is not what I meant.
16:44:21 <elliott> ais523: no, it wouldn't; there is no lazy id, there are no lazy functions of type (a -> a)
16:44:21 <ais523> so the two are the same
16:44:25 <elliott> ais523: it's an incoherent question
16:44:43 <ais523> elliott: have you seen the hardware implementation of call-by-name id? it is quite undeniably lazy
16:44:57 <elliott> ais523: no shit, "lazy" changes meanings in different evaluation orders
16:45:07 <elliott> ais523: but call-by-name is a valid strategy for Haskell too
16:45:11 <elliott> ais523: id is still strict in it
16:45:23 <kallisti> elliott: side-effects involve modifying state that is not part of the result of the expression. seq does this. clearly (+) does not do that.
16:45:27 <elliott> you can't /observe/ its supposed "laziness" at all
16:45:34 <elliott> and it's the semantics that matter, not the operations
16:45:35 <ais523> elliott: except with a multimeter, right
16:45:46 <elliott> kallisti: seq DOES NOT MODIFY ANY STATE
16:46:01 <elliott> you can implement haskell in fucking term rewriting
16:46:05 <ais523> arguably, I'd say that id is both strict /and/ lazy
16:46:27 <kallisti> elliott: seq would still be a side-effect in those circumstances.
16:46:41 <elliott> kallisti: you do not understand what a side-effect is.
16:47:10 <ais523> elliott: well, "lazy id" is always forced instantly; that's why it's the same as being strict
16:47:33 <elliott> ais523: you're bringing details like "force" into it that don't exist at this layer
16:47:33 <ais523> aren't all unary operators either strict, or ignore their argument, with your definition?
16:47:40 <kallisti> elliott: I think you just have a very weird notion of what a side-effect is.
16:47:50 <elliott> ais523: if you don't ignore an argument, you force it
16:48:03 <kallisti> elliott: clearly seq makes an /observable/ difference to the operational semantics of the program that /has nothing to do with its return value/
16:48:13 <ais523> anyway, I agree with your definition of "strict", but am not convinced it's the opposite of "lazy"
16:48:18 <elliott> kallisti: ah! what you mean is that since
16:48:34 <elliott> therefore, again (+) on Int has a side-effect!
16:48:38 <kallisti> no. I'm sorry, but you're stupid.
16:48:47 <elliott> kallisti: but seriously though, you can stop bothering, because you're... wrong
16:48:57 <elliott> and have no idea what you're talking about
16:49:10 <kallisti> elliott: nice strawman though. "oh you actually meant this. now I will demonstrate that what I said is wrong."
16:49:22 <elliott> hey guys, I heard I/O is relevant to the definition of turing completeness
16:49:47 <elliott> reaaaaaaally? I think I'll argue the issue for a few hours with people who know more about the topic than me
16:49:58 <kallisti> elliott: and this is relevant to what we're talking about how?
16:50:09 <kallisti> elliott: it basically just sounds like a personal attack to me. how silly.
16:50:18 <ais523> kallisti: I think your problem is, that seq a b is designed to calculate a value depending on both a and b; the fact that the value is always the same as b, doesn't change the fact that it depends on a
16:50:25 <elliott> the relevance is that you should really just drop it before this log becomes more personally embarrassing to you in the future
16:50:28 <elliott> it wasn't intended as an argument
16:50:30 <ais523> you could implement seq on integers as seq i j = (i-i) + j
16:50:48 <elliott> ais523: I've occasionally explained seq as just magically knowing the constructors of every data-type
16:51:06 <ais523> and the only reason you think that the generalised seq is side-effecty is that there's no way to get a polymorphic version
16:51:13 <elliott> that kind of breaks down for functions, but so does seq :)
16:51:25 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
16:51:26 <elliott> (seq lets you distinguish _|_ and (const _|_))
16:51:34 <elliott> (another thing kallisti has been confused about, incidentally)
16:51:36 <kallisti> ais523: seq /doesn't/ calculate a value based on a and b though. only b.
16:51:50 <ais523> the value depends on a by definition
16:52:03 <ais523> thus, optimising out the dependency on a, just because the return value isn't affected by it, is wrong
16:52:18 <ais523> if you're going to call the dependency a side-effect, you have a pretty weird definition of side-effect
16:52:29 <kallisti> it has nothing to do with dependency.
16:52:49 <ais523> elliott: how strict is the first argument to seq? does it only go as far as the first constructor, or does it figure out the value "all the way"?
16:53:03 <ais523> why does (a+b) go into an infinite loop if either a or b are infinite loops?
16:53:12 <elliott> ais523: (so, to the first constructor or a lambda, basically)
16:53:18 <kallisti> ais523: strictness and laziness has nothing to do with side-effects, first of all.
16:53:29 <elliott> that's why seq isn't side-effectful
16:53:43 * elliott is just going to keep stating facts rather than actually trying to engage in futile argument.\
16:53:44 <kallisti> elliott: it has to do with what is computed and what is returned.
16:54:02 <ais523> elliott: I admit that seq still feels a bit non-Haskellish to me, but that's not because of side effects, but because it does weird things to eval order
16:54:13 <elliott> ais523: a lot of people don't like it
16:54:22 <kallisti> elliott: and in this case, seq returns b and forced a. this is /precisely/ why you can't simply optimize seq away because it performs a side-effect unrelated to just evaluating b and returning that.
16:54:23 <elliott> ais523: Haskell 1.4 was better
16:54:28 <elliott> ais523: it had class Eval a where seq :: a -> b -> b
16:54:32 <elliott> and e.g. functions weren't an instance
16:54:40 <elliott> and every ADT got an Eval instance for free
16:54:51 <elliott> that was good because fully polymorphic functions didn't get parametricity fucked up
16:55:06 <elliott> kallisti: you will never understand why you are wrong until you stop thinking in terms of operations like "forced".
16:55:15 <ais523> kallisti: do you think that (\a b->(b-b)+a)::(Int -> Int -> Int) can be optimised to const::(Int -> Int -> Int)?
16:55:16 <elliott> there are two levels: semantics, which do _not_ involve things like "forcing" and "mutation"
16:55:22 <elliott> and implementation, which SOMETIMES INVOLVES MUTATION
16:55:27 <ais523> elliott: I like finding misconceptions via binary search
16:55:36 <elliott> GHC mutates TONS of things in the process of evaluating COMPLETELY PURE (even seq-less, if you think that matters) expressions
16:55:38 <ais523> whether in someone else's view or mine
16:55:53 <elliott> that does NOT MEAN THOSE EXPRESSIONS MUTATE, the expressions DO NOT HAVE SIDE-EFFECTS
16:56:04 <elliott> and that is the last I will say on the matter, unless I decide to be a jerk from the sidelines again
16:56:13 <elliott> which is, admittedly, fairly likely.
16:56:31 <elliott> ais523: I'm not sure that works in the general case
16:56:40 <elliott> ais523: (binary search, I mean)
16:56:47 <elliott> sometimes people are just wrong all the way down
16:56:56 <ais523> elliott: indeed, but you can often narrow it down somewhat
16:57:12 <kallisti> ais523: because they don't do the same thing? you're making the assumption that Num obeys any kind of laws.
16:57:31 <ais523> kallisti: did you see the ::Int?
16:57:49 <ais523> right, in general you couldn't, because of polymorphism
16:58:07 <kallisti> ais523: I mean, it /could/ be optimized. it would do the same thing.
16:58:14 <ais523> kallisti: no it wouldn't
16:58:31 <ais523> so, would you say that b-b has side effects?
16:58:45 <ais523> now, if I flip that expression
16:58:58 <ais523> to (\a b->(a-a)+b)::(Int->Int->Int)
16:59:03 -!- Phantom_Hoover has joined.
16:59:04 <ais523> I have seq::(Int->Int->Int)
16:59:08 <ais523> but I can't optimise it to flip const
16:59:19 <ais523> based on your arguments
16:59:23 <kallisti> ais523: I have never once claimed that seq can be optimized to flip const
16:59:40 <ais523> <kallisti> elliott: and in this case, seq returns b and forced a. this is /precisely/ why you can't simply optimize seq away because it performs a side-effect unrelated to just evaluating b and returning that.
16:59:41 <kallisti> ais523: in fact, the reason it can't is because seq has side-effects...
16:59:45 <ais523> you claimed that it's because it has side effects
16:59:56 <ais523> whereas I've given an implementation on the integers that doesn't have side effects
16:59:59 <ais523> and yet still can't be optimised away
17:00:02 -!- azaq23 has joined.
17:00:12 <kallisti> ais523: there are other reasons things can't be optimized.
17:00:25 <ais523> and those are the reasons that seq can't be optimised
17:00:49 <ais523> elliott: hmm, I suppose that this means that in languages like Agda, it's possible for an integer to be lazily positive
17:00:50 <kallisti> ais523: oh I see what you're saying.
17:00:58 <ais523> as in, forced only so far as being positive, rather than to its actual value
17:01:05 <ais523> because integers actually have type constructors there
17:01:33 <kallisti> ais523: but I still think seq performs a side-effect, because side-effects are related to computing expressions
17:02:04 <ais523> hmm, now I'm wondering what seq /does/ do if given a function
17:02:18 <ais523> presumably just ignores it
17:02:45 <ais523> wait, fix id isn't afunction
17:03:04 <elliott> <ais523> elliott: hmm, I suppose that this means that in languages like Agda, it's possible for an integer to be lazily positive
17:03:09 <ais523> > seq (const $ fix id) 0
17:03:10 <elliott> ais523: Agda doesn't have _|_
17:03:17 <elliott> so the concept of laziness/strictness doesn't exist
17:03:23 <ais523> elliott: indeed, it was a different "this"
17:03:28 <ais523> and I meant in terms of implementation
17:03:33 <ais523> it's not user-observable at all
17:03:40 <kallisti> ais523: things are naturally forced in Haskell semantics by being referring to in functions, or being evaluated in some way. so being forced as the result of being used in an expression is not a side-effect. I'm not saying "forcing values is a side-effect" I'm saying "forcing values that you don't use as part of an expression that you return is a side-effect"
17:03:55 <ais523> hmm, does this mean Agda is sub-TC?
17:04:04 <ais523> (as in, you can't write a program without a proof it terminates?)
17:04:12 <elliott> kallisti: nothing is forced in Haskell's semantics.
17:04:22 <ais523> kallisti: well, the argument a /is/ used, that's the point
17:04:27 <ais523> it's not used for anything, but it's still used
17:04:31 <elliott> ais523: Agda is sub-TC, yes.
17:04:36 <elliott> unless you turn off the termination checker.
17:04:46 <ais523> imagine it being subtracted from itself via a generic magic subtraction operation, that returns 0 if you subtract anything from itself
17:05:21 <kallisti> ais523: ...it's not relevant to the computed result. in much the same way that the act of writing bytes to a file is irrelevant to the result of writeFile
17:05:32 <elliott> the result of writeFile is an IO action
17:05:37 <elliott> and all that action does is write bytes to af ile
17:05:59 <elliott> writeFile is also referentially transparent, i.e. returns the same action for the same arguments always
17:06:22 <ais523> elliott: well, writeFile doesn't have side effects; unsafePerformIO does when given its return value, but writeFile doesn't
17:07:16 <ais523> one possible implementation of IO actions would be as C programs, wouldn't it? and you could define all the functions returning IO actions, and things like >>= for IO, as operating on those programs
17:07:31 <ais523> and then unsafePerformIO and the runtime would simply run the programs produced
17:07:37 <ais523> (it'd be quite a bad impl, but it'd be possible)
17:08:00 <elliott> ais523: on that riff: http://conal.net/blog/posts/the-c-language-is-purely-functional (in response to people claiming Haskell is purely-functional)
17:08:19 <ais523> wait, /another/ elliott?
17:08:28 <elliott> conal elliott is the more famous elliott
17:08:41 <elliott> there's him and another two elliotts in #haskell at the best of times
17:08:44 <elliott> well, not the best of times
17:08:47 <elliott> because one of them is elliottcable
17:09:39 <ais523> hmm, it's a little wrong; #undef is a purely functional operation in CPP, because it serves to end a scope, rather than do anything fundamentally side-effecty
17:10:15 <elliott> ais523: nah, you can use it out of order
17:10:33 <kallisti> ...I think you guys have a weird definition of side-effect.
17:10:51 <elliott> kallisti: your definition is incoherent
17:11:01 <elliott> and makes Haskell-even-without-seq side-effectful
17:11:10 <elliott> (you would claim it isn't, but that's because your definition is self-contradictory)
17:11:28 <kallisti> Haskell-even-without-seq is side-effectful...
17:11:55 <ais523> "Having a baby is often a occasion whenever you must be careful because the outcomes of earning a mistake might be serious."
17:12:20 <kallisti> kallisti: well, "pure Haskell without side-effects" has no side-effects, yes.
17:12:33 <ais523> kallisti: did you just nickping yourself?
17:12:48 <ais523> wow, elliott and kallisti must be the same person, it's the only way to explain such a mistake
17:12:56 <elliott> kallisti: indeed it doesn't: unfortunately, your definition makes it so
17:13:00 <ais523> (and the only conclusion from that is, that that person is trolling me really heavily)
17:13:15 <elliott> you just don't realise it, because you don't know what your definition is, because you don't understand it, because you don't understand purity
17:13:26 <kallisti> elliott: ah, because forcing a value as the result of computing it is a side-effect, under my definition, yes?
17:13:34 <kallisti> (except it's not, but please explain)
17:13:39 <ais523> with a definition of "same arguments always gives same results", seq is perfectly pure
17:13:45 <ais523> as its result depends only on its arguments a and b
17:13:54 <elliott> kallisti: nah, ais523 has taken the torch of actually attempting to explain to you _why_ you're wrong
17:14:21 <ais523> elliott: to be fair, I didn't understand at the start of the conversation, I just figured it out pretty quickly
17:14:22 <kallisti> as I said, my claim is not that "forcing a value is a side-effect"
17:14:39 <kallisti> because values are forced all the time when no side-effects are occuring.
17:14:44 <elliott> ais523: yes, such wonders tend to happen when you start without assuming you're correct :P
17:14:58 <ais523> Haskell is something that I don't find very intuitive
17:15:37 <ais523> although I've occasionally wished for Haskelly monads elsewhere (especially for error handling); you could do it in OCaml but you have to lazify everything by hand, which is irritating
17:16:12 <ais523> (where lazifying is the easiest way to make statements into what are effectively Either actions)
17:17:40 <kallisti> "this action is performed, and is completely irrelevant to the output of the expression"
17:18:02 <ais523> elliott: I disagree, as I disagree with the "completely irrelevant"
17:18:04 <elliott> evaluating a pure value is not an "action" in the side-effectful sense
17:18:12 <ais523> clearly, you get an infinite loop if a is an infinite loop
17:18:15 <ais523> thus, a isn't irrelevant
17:18:21 <elliott> ais523: pinging the wrong person, dude
17:18:31 <ais523> elliott: I was disagreeing with where you found the error
17:18:39 <elliott> ais523: I was just disagreeing with a different part.
17:18:49 -!- MSleep has changed nick to MDude.
17:18:49 <ais523> I think his statement's wrong even without the "action is performed" part
17:19:04 <elliott> ais523: Were I trying to actually deconstruct kallisti's argument in its entirety, I would have to start by rejecting everything he says, as it is worded in terms of imperative machine operations, not Haskell's pure, timeless semantics.
17:19:18 <elliott> He would almost certainly interpret this as me trolling him with stubbornness.
17:19:31 <kallisti> elliott: ah okay so forcing a in a `seq` b is not an action, it's just an observable effect of evaluating the expression that has nothing to do with the return value. got it.
17:19:32 <ais523> kallisti: hmm, to put it a different way: you seem to think that side-effects are defined in terms of "X happens and is not useful", rather than in terms of "X happens and does something not reflected by the return value Y"
17:19:40 <elliott> kallisti: It has to do with the return value.
17:19:47 <elliott> If a is _|_, then the return value is _|_.
17:20:05 <kallisti> ais523: you seem to be thinking that I'm thinking the opposite of what I'm thinking, and then go on to describe exactly what I'm thinking to be the thing I should be thinking.
17:20:40 <ais523> elliott: hmm, is it sanely possible to add T to a language as well as _|_?
17:21:04 <elliott> ais523: well, _|_ is the value of every type, I guess T is the value of no type?
17:21:07 <ais523> then your values would be lattice elements, I think
17:21:18 <elliott> ais523: ordered by well-definedness
17:21:24 <elliott> ezyang has a long post series about this
17:21:35 <ais523> well, it's only a semilattice in Haskell
17:21:55 <kallisti> elliott: can Haskell talk about _|_ in that way...
17:22:02 <ais523> _|_ is a suitable value for use in any context; whereas T is a value which, if a context accepts that, it'll accept anything
17:22:05 <elliott> kallisti: We're not Haskell, we're humans.
17:22:15 <elliott> Haskell's semantics most definitely involve _|_.
17:22:32 <ais523> kallisti: in general, _|_ is meaningful, but it's impossible for a computer to always detect its existence
17:22:38 <kallisti> elliott: does haskell's semantics involve side-effects?
17:22:42 <ais523> (and you get an infinite loop if it's there, but can't)
17:23:15 <elliott> kallisti: No, although the description of how IO is executed does.
17:23:41 <ais523> I think ghc can detect a few trivial instances of _|_ existing
17:23:44 <elliott> kallisti: Note that there is a function which causes the evaluation of its first argument when forced, but does _not_ return _|_ when the first argument is _|_.
17:23:51 <lambdabot> Only unit numeric type pattern is valid
17:24:01 <lambdabot> No instance for (GHC.Real.Fractional GHC.Types.Int)
17:24:12 <lambdabot> No instance for (GHC.Real.Fractional GHC.Types.Int)
17:24:13 <elliott> kallisti: That function is "start evaluating the first argument in another thread, and return the second immediately" (it is only distinguishable from flip const when talking about operations, not semantics).
17:24:21 <elliott> kallisti: It is also completely pure and has no side-effects.
17:24:26 <kallisti> elliott: how about... operational semantics?
17:24:40 <ais523> aha, division isn't defined on the integers in Haskell
17:24:45 <ais523> that… makes a lot of sense, actually
17:24:51 <elliott> kallisti: So if you think the return value matters as to whether something has a "side-effect", you're wrong.
17:25:00 <lambdabot> forall a. (Integral a) => a -> a -> a
17:25:10 <ais523> elliott: and I was thinking that "integer division" quite possibly was
17:25:19 <lambdabot> forall a. (Integral a) => a -> a -> a
17:25:22 <ais523> so yes, that's a _|_ that was caught by the compiler, as it's a pretty easy one to catch
17:25:50 <ais523> hmm, now I'm wondering what split-complex numbers are used for
17:25:53 <elliott> ais523: N.B. there are actually semantics given to Haskell's _|_s to explain exceptions
17:26:04 <kallisti> elliott: question: is a guaranteed to evaluate before seq returns?
17:26:20 <ais523> elliott: you mean exceptions are the reason that _|_ is part of the semantics rather than inferred from it?
17:26:26 <ais523> I'm not entirely convinced I've parsed your line correctly
17:26:30 <elliott> kallisti: You're talking about operations again.
17:26:42 <elliott> ais523: I just mean that we don't say exceptions work because the compiler magically realised _|_ was there
17:26:45 <kallisti> elliott: operations seem particularly relevant to side-effects.
17:26:54 <elliott> ais523: OTOH, the semantics for exceptions are really kind of gnarly, so we ignore them when not talking about exceptions :P
17:27:04 <elliott> kallisti: yep, good thing there are no side-effects nivolved
17:27:05 <ais523> I take it you can't catch an exception in Haskell?
17:27:13 <ais523> (I'd be pretty surprised if you could, all things considered)
17:27:18 <ais523> (but Haskell surprises me a lot)
17:27:19 <elliott> they'd be useless otherwise
17:27:30 <elliott> :t Control.Exception.catch
17:27:31 <lambdabot> forall a e. (GHC.Exception.Exception e) => IO a -> (e -> IO a) -> IO a
17:27:32 <kallisti> elliott: in the denotational semantics, sure. but in the operational semantics... yes?
17:27:42 <elliott> :t Control.Exception.throw
17:27:42 <lambdabot> forall e a. (GHC.Exception.Exception e) => e -> a
17:27:43 <elliott> :t Control.Exception.throwIO
17:27:44 <lambdabot> forall e a. (GHC.Exception.Exception e) => e -> IO a
17:27:53 <elliott> kallisti: haskell has no mandatory operational semantics
17:28:02 <elliott> implementations can do what they will.
17:28:09 <elliott> if an implementation proves the first argument to seq always terminates, it can discard it.
17:28:13 <ais523> elliott: oh, catch is an IO action? that makes a lot of sense too
17:28:37 <elliott> ais523: *a function taking an IO action and a function taking an exception and returning an IO action, and returning an IO action
17:28:56 <ais523> elliott: well, I knew I was going to get a correction like that
17:29:06 <ais523> I should have said that a given try…catch block is an IO action
17:29:14 <kallisti> elliott: I think I'm done pressing the issue.
17:29:28 <elliott> kallisti: which is not the same thing as realising you're wrong, I presume?
17:29:37 <kallisti> elliott: this conversation has been enlightening. but no, I don't think I'm wrong on this one.
17:29:52 <kallisti> elliott: but I do understand your perspective now. so cool.
17:30:14 <elliott> it's literally objectively correct
17:30:25 <elliott> you won't find a single person who knows their shit who will agree with you
17:31:15 <elliott> yeah. you alone will be correct in your tower of oh shit, somehow I'm a haskell expert by pure chance
17:31:19 <ais523> elliott: to be fair, I'm not sure that the concept that kallisti calls "side-effect" is useless, but I'm not sure how easy it is to define
17:31:22 <elliott> ais523: Prelude Control.Exception> catch (print (1 `div` 0)) (\e -> putStrLn $ "Exception: " ++ show (e::SomeException))
17:31:24 <ais523> and it needs a better name
17:31:49 <ais523> elliott: the IO action was the bit I missed when thinking through it
17:31:51 <kallisti> ais523: elliott: my concept involves operations. (aka what actually happens when you implement things)
17:31:57 <elliott> ais523: Haskell exceptions are interesting even then because of laziness and and ambiguity
17:32:03 <ais523> having it as an IO action means that it makes sense to say when it happens
17:32:11 <elliott> ais523: (1 `div` 0) + undefined -- which exception does this throw?
17:32:13 <elliott> divide by 0, or undefined?
17:32:15 <ais523> which gives enough context to know how to catch it
17:32:25 <ais523> elliott: depends on the impl, I guess
17:32:35 <elliott> ais523: nope, it's actually formally ambiguous
17:32:42 <elliott> I suppose an implementation could give guarantees, but it wouldn't /want/ to
17:32:52 <elliott> ais523: that's basically the reason exception-catching is in IO
17:32:58 <elliott> if not for that, it would be pure
17:33:04 <ais523> elliott: I meant unspecified, not impl-defined
17:33:43 <elliott> ais523: Prelude Control.Exception> catch (evaluate [1,2,undefined] >> return ()) (\e -> putStrLn $ "Exception: " ++ show (e::SomeException))
17:33:43 <elliott> Prelude Control.Exception>
17:33:50 <ais523> also, I think if catch were pure, and just caught the existence of an exception rather than a specific exception, you'd need to be careful with seq and similar things to make sure that the exception happened inside the catch rather than outside
17:33:53 <elliott> Prelude Control.Exception> catch (evaluate (undefined :: [Int]) >> return ()) (\e -> putStrLn $ "Exception: " ++ show (e::SomeException))
17:33:53 <elliott> Exception: Prelude.undefined
17:34:25 <ais523> aha, evaluate only forced it one level
17:34:31 <elliott> (evaluate is just (\a -> a `seq` return a), except with some extra magic)
17:34:38 <elliott> (so that evaluate undefined `seq` () === ())
17:34:47 <ais523> so the first case didn't exception because it never cared about the elements of the list, just that it had a head and a tail
17:34:47 <elliott> (i.e. the evaluation only happens when you /execute/ the action)
17:35:06 <kallisti> elliott: I've basically come to the conclusion that I'm talking about something completely different. So it's not so much that I think I've PROVED EVERYONE WRONG. it's just that those people being right and me being right are irrelative
17:35:15 -!- zzo38 has quit (Remote host closed the connection).
17:35:20 <ais523> elliott: which is ofc perfectly meaningful as an IO action, because the whole point of IO actions is that they happen at a particular time
17:35:35 <elliott> kallisti: yoru concept is self-contradictory, so it's gonna need a hell of a lot of reworking to make sense.
17:35:49 <elliott> ais523: well, the point is that they have side-effects
17:35:56 <elliott> ais523: the same IO action can execute at ten different times, or none
17:36:17 <ais523> but each time it's executed, you can say when
17:36:27 <ais523> I think the point, even more than having side-effects, is that they execute in order
17:36:36 <ais523> but the side-effects are useful in practice ;)
17:36:46 <ais523> IO would be useful even if the universe were pure
17:36:51 <kallisti> elliott: I haven't found the contradiction. If you have it I'd like to see, but I doubt you have the patience to go down that route.
17:37:35 <ais523> (btw, I still haven't figured out how to do IO-style things meaningfully in Feather; the problem's not evaluation order, as that's trivially defined, but other problems)
17:38:06 <ais523> (it's possible to create a temporal monad that keeps track of meta-time, and it's probably a useful concept, but I want to avoid it if possible)
17:38:21 <ais523> (especially as it breaks the purity of the language)
17:41:26 <kallisti> elliott: the problem with seq _|_ b = _|_; seq a b = b is that there's no computer that can actually do that.
17:41:38 <kallisti> which, when you're talking about operational semantics, is relevant.
17:41:46 <elliott> my computer does that when I use seq
17:41:53 <elliott> you never claimed to be talking about operational semantics at the start of this
17:41:57 <elliott> you just said seq has side-effects
17:42:02 <elliott> shut up about this, you're wrong
17:43:01 <kallisti> elliott: I didn't realize that's what I was talking about until it became apparent that we were talking about different definitions of side-effect.
17:43:22 <elliott> right: you didn't find out you were wrong, just right in a way we failed to consider.
17:43:31 <elliott> if only every wrong person could be so lucky
17:45:34 <Gregor> `addquote <elliott> right: you didn't find out you were wrong, just right in a way we failed to consider.
17:45:34 <Gregor> <elliott> if only every wrong person could be so lucky
17:45:34 <lambdabot> Gregor: You have 1 new message. '/msg lambdabot @messages' to read it.
17:45:41 <HackEgo> 742) <elliott> right: you didn't find out you were wrong, just right in a way we failed to consider.
17:45:47 <HackEgo> *poof* <elliott> right: you didn't find out you were wrong, just right in a way we failed to consider.
17:45:54 <elliott> Gregor: I might like it more with just that line
17:46:08 <Gregor> `addquote <elliott> right: you didn't find out you were wrong, just right in a way we failed to consider. <elliott> if only every wrong person could be so lucky
17:46:10 <HackEgo> 742) <elliott> right: you didn't find out you were wrong, just right in a way we failed to consider. <elliott> if only every wrong person could be so lucky
17:46:18 <lambdabot> fizzie said 2h 56m 28s ago: A spammy, useless message.
17:46:30 <Gregor> @tell fizzie SPAM SPAM SPAM SPAM SPAM SPAM SPAM
17:46:35 <Gregor> @tell fizzie FRIED EGGS AND SPAM
17:50:16 <kallisti> elliott: does side-effect have a formal definition?
17:50:53 <elliott> referential transparency is a good one.
17:53:28 <Gregor> It blew up the moon, but no value accessible thru my references has changed.
17:54:02 <kallisti> I don't think they're equivalent (aka referential transparency <-> no side-effects )
17:54:12 <kallisti> or well, I don't think they're related in that way
17:54:21 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
17:54:23 <elliott> Gregor: Yeah, but eventually you call it so much that the computer explodes.
17:54:27 <elliott> And THEN it stops giving the same results.
17:54:58 <Gregor> This function, on certain inputs, will take more time than the shelf life of the processor. Therefore it has side effects.
17:55:27 <elliott> (I don't actually think referential transparency by itself = purity, and especially not "referential transparency on some hardware", but it's a start :P)
17:56:10 <elliott> kallisti: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.27.7800 This is apparently the most popular definition.
17:56:53 <Gregor> elliott: This paper should have the subtitle "Baby Don't Hurt Me"
17:57:19 <elliott> Gregor: Stretching things a bit :P
17:57:37 <Gregor> elliott: AND YET IT IS NOW STUCK IN YOUR HEAD </victory>
17:57:50 <elliott> Gregor: What is the point of turning into a tortured What Is Love reference, even if it doesn't fit at all?
17:59:05 <ais523> elliott: that reminds me of Dan Ghica doing things like calling fork() in callbacks in order to break other people's proven security properties
17:59:39 <ais523> because their formal model didn't allow for /that/ sort of side effect
18:01:22 <kallisti> ais523: all programs are the side-effect of me (or my computer) creating them.
18:01:32 <kallisti> therefore: everything is side-effects.
18:02:19 <elliott> ais523: arguably, IO with concurrency should have a different monad to IO without concurrency
18:02:22 <elliott> since they're so different
18:02:42 <elliott> and a lot of things might want to take actions in the latter as arguments
18:02:52 <elliott> (with ofc sequentially :: IO a -> ConcIO a)
18:03:12 <ais523> that's also a meaningful operation
18:03:15 <elliott> no, that defeats the whole point
18:03:23 <elliott> because it lets you fork from within a sequential callback
18:03:24 <kallisti> does crashing my computer as the result of a memory link count as a side-effect? :3 it's certainly not related to the return value.
18:03:37 <ais523> elliott: but you'd have to unfork again before returning
18:03:52 <ais523> anyway, I'm about to miss a bus, so bye everyone; I'll probably be back later
18:03:55 -!- ais523 has quit (Remote host closed the connection).
18:03:59 <elliott> ais523: err? fork :: ConcIO a -> ConcIO ThreadId was the operation I was imagining ConcIO would have
18:04:09 <elliott> in addition to standard boring stuff on ThreadIds, and MVars
18:06:05 -!- MDude has quit (Ping timeout: 248 seconds).
18:06:55 -!- Phantom_Hoover has joined.
18:08:04 <kallisti> what, for some reason hackage isn't responding.
18:12:39 -!- Klisz has joined.
18:16:06 <elliott> -- pure x = slide (pure x) x
18:16:06 <elliott> -- slide fs f <*> slide xs x = slide (fs <*> xs) (f x)
18:16:42 <kallisti> the first one is known as the "pure slide pure" law
18:16:51 <kallisti> and the second one is known as the "slide slide slide" law
18:17:10 <kallisti> they also double as dance moves.
18:18:10 <elliott> @pl \f g h x -> f (g x) (h x)
18:18:24 <elliott> pure = liftM2 slide pure id
18:18:32 <elliott> pure = slide <$> pure <*> id
18:21:29 <lambdabot> No instance for (GHC.Show.Show (m b))
18:21:29 <lambdabot> arising from a use of `M3862060386...
18:21:34 <lambdabot> Ambiguous type variable `a' in the constraints:
18:21:43 <lambdabot> Ambiguous type variable `a' in the constraints:
18:21:54 <lambdabot> Couldn't match expected type `SimpleReflect.Expr -> a'
18:21:57 <kallisti> serpkweroweirowieriowetioweriwet
18:23:54 <lambdabot> forall (m :: * -> *) a b. (SimpleReflect.FromExpr (m a), SimpleReflect.FromExpr (m b), Monad m) => m b
18:24:06 <lambdabot> Ambiguous type variable `a' in the constraint:
18:25:21 <fungot> Phantom_Hoover: ' only a bit?' more voices were raised.
18:27:42 <kallisti> > (\x -> "(f " ++ x ++ ")") >>= (\x y -> "(g " ++ x ++ " " ++ y ++ ")") $ "x"
18:31:55 <kallisti> I wish hackage would stop being down.
18:32:46 <elliott> -- fromZip . toZip = toZip . fromZip = id
18:32:46 <elliott> -- fromZip (pure x) = slide (fromZip (pure x)) x
18:32:46 <elliott> -- fromZip (toZip (slide fs f) <*> toZip slide xs x)
18:32:46 <elliott> -- = slide (fromZip (toZip fs <*> toZip xs)) (f x)
18:33:31 <kallisti> fromZip . toZip = toZip . fromZip = id
18:34:31 <Sgeo> How does fromZip make sense for arbitrary arguments?
18:34:42 <Sgeo> (I'm just going by the name)
18:34:50 <elliott> class (Applicative (Zip v)) => Space v a | v -> a where
18:34:50 <elliott> -- fromZip . toZip = toZip . fromZip = id
18:34:50 <elliott> -- fromZip (pure x) = slide (fromZip (pure x)) x
18:34:50 <elliott> -- fromZip (toZip (slide fs f) <*> toZip slide xs x)
18:34:51 <elliott> -- = slide (fromZip (toZip fs <*> toZip xs)) (f x)
18:35:06 <elliott> data Two = Two {-# UNPACK #-} !Double {-# UNPACK #-} !Double deriving (Show)
18:35:06 <elliott> instance Space Two Double where
18:35:07 <elliott> data Zip Two a = TwoZ !a !a
18:35:09 <elliott> toZip (Two x0 x1) = TwoZ x0 x1
18:35:11 <elliott> fromZip (TwoZ x0 x1) = Two x0 x1
18:35:13 <elliott> slide (Two _ x1) y = Two x1 y
18:35:15 <elliott> instance Functor (Zip Two) where
18:35:17 <elliott> fmap f (TwoZ x0 x1) = TwoZ (f x0) (f x1)
18:35:19 <elliott> instance Applicative (Zip Two) where
18:35:22 <kallisti> http://www.textfiles.com/uploads/2001.txt I have no idea what this is but it says "Monad Hate Barrier"
18:35:23 <elliott> TwoZ f0 f1 <*> TwoZ x0 x1 = TwoZ (f0 x0) (f1 x1)
18:35:27 <kallisti> there are also 159 mentions of the word monad
18:35:51 <elliott> it's the numerical dictionary!
18:36:13 <elliott> Soren Greenwood's Conspiracy Theory to Explain all Other Conspiracy Theories (January 10, 2001)
18:37:33 <kallisti> elliott: wow I don't even know how to go about this...
18:38:04 <elliott> "*This* is Yammer's official position on the subject: our goal at Yammer is to revolutionize the way modern workers collaborate and we'll use whatever tools will allow us to iterate faster on that goal. If Scala is that tool, we'll use Scala; if Java is that tool, we'll use Java; if INTERCAL is that tool, we'll use INTERCAL. (We don't expect to have to use INTERCAL; don't worry.)"
18:38:09 <elliott> where's ais when you need him
18:38:14 <elliott> kallisti: from top to bottom, one presumes
18:39:49 <kallisti> as far as I can tell it's just putting together loose mental associations until everything becomes a conspiracy theory?
18:40:58 <kallisti> if I ever see "monad hate barrier" I know it has something to do with 151...
18:41:11 -!- derrik_ has joined.
18:41:15 -!- derrik_ has quit (Client Quit).
18:41:54 -!- derrik has quit (Ping timeout: 240 seconds).
18:45:22 -!- monqy has joined.
18:46:37 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
18:46:55 <kallisti> @let powerOfTwo n = length . nub $ filterM (const [True, False]) [1 .. abs n]
18:47:34 <kallisti> elliott: behold, the most efficient way to compute powers of two.
18:49:31 <lambdabot> Overlapping instances for GHC.Show.Show (a -> GHC.Types.Int)
18:51:51 <elliott> 07:09:19: <oerjan> apparently tunes also uses sidereal time.
18:51:55 <elliott> @tell oerjan WHAT DO YOU HAVE AGAINST GLOGBOT
18:51:59 <elliott> *@ask oerjan WHAT DO YOU HAVE AGAINST GLOGBOT
18:52:01 <elliott> @ask oerjan WHAT DO YOU HAVE AGAINST GLOGBOT
18:52:14 <kallisti> > let twoPower n = [recip, id] !! (fromEnum (n < 0)) . length . nub . filterM (const [True, False]) $ [1 .. abs n] in map twoPower [1..10]
18:52:15 <lambdabot> cannot mix `GHC.List.!!' [infixl 9] and `L..'...
18:52:27 <kallisti> > let twoPower n = ([recip, id] !! (fromEnum (n < 0))) . length . nub . filterM (const [True, False]) $ [1 .. abs n] in map twoPower [1..10]
18:52:27 <lambdabot> No instance for (GHC.Real.Fractional GHC.Types.Int)
18:52:54 <kallisti> > let twoPower n = ([recip, id] !! (fromEnum (n < 0))) . genericLength . nub . filterM (const [True, False]) $ [1 .. abs n] in map twoPower [1..10]
18:52:56 <lambdabot> [0.5,0.25,0.125,6.25e-2,3.125e-2,1.5625e-2,7.8125e-3,3.90625e-3,1.953125e-3...
18:53:11 <kallisti> > let twoPower n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . nub . filterM (const [True, False]) $ [1 .. abs n] in map twoPower [1..10]
18:53:12 <lambdabot> [2.0,4.0,8.0,16.0,32.0,64.0,128.0,256.0,512.0,1024.0]
18:53:42 <kallisti> > let twoPower n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . nub . filterM (const [True, False]) $ [1 .. n] in map twoPower [1..10]
18:53:43 <lambdabot> [2.0,4.0,8.0,16.0,32.0,64.0,128.0,256.0,512.0,1024.0]
18:53:44 -!- MSleep has joined.
18:53:46 <kallisti> erm... now even twice as good!
18:53:49 -!- MSleep has changed nick to MDude.
18:54:05 <kallisti> > let twoPower n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . nub . filterM (const [True, False]) $ [1 .. abs n] in map twoPower -2
18:54:05 <lambdabot> Overlapping instances for GHC.Show.Show ([a] -> [a1])
18:54:10 <kallisti> > let twoPower n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . nub . filterM (const [True, False]) $ [1 .. abs n] in twoPower -2
18:54:11 <lambdabot> Overlapping instances for GHC.Show.Show (a -> a1)
18:54:13 <kallisti> jserjgiuweriuwehriuwheriuhdfiuhweruihweiuhweiruhweriuhwetiuweht
18:54:16 <olsner> too pointy, make it more pointless
18:54:18 -!- ais523 has joined.
18:54:24 <kallisti> > let twoPower n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . nub . filterM (const [True, False]) $ [1 .. abs n] in (twoPower -2)
18:54:24 <lambdabot> Overlapping instances for GHC.Show.Show (a -> a1)
18:54:32 <kallisti> > let twoPower n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . nub . filterM (const [True, False]) $ [1 .. abs n] in twoPower (-2)
18:54:53 <kallisti> @pl (\n -> ([id,recip] !! (fromEnum (n < 0))) . genericLength . nub . filterM (const [True, False]) $ [1 .. abs n])
18:54:53 <lambdabot> ap ((. (genericLength . nub . filterM (const [True, False]))) . ([id, recip] !!) . fromEnum . (< 0)) (enumFromTo 1 . abs)
18:55:25 <ais523> doing a conditional by indexing a list? how Pythonic
18:55:44 <elliott> 07:29:57: <kallisti> pikhq_: I knew they were Christian based but not anti-gay
18:55:48 <elliott> kallisti: http://en.wikipedia.org/wiki/Chick-fil-A#Religious_and_political_views
18:55:56 <elliott> ais523: <elliott> "*This* is Yammer's official position on the subject: our goal at Yammer is to revolutionize the way modern workers collaborate and we'll use whatever tools will allow us to iterate faster on that goal. If Scala is that tool, we'll use Scala; if Java is that tool, we'll use Java; if INTERCAL is that tool, we'll use INTERCAL. (We don't expect to have to use INTERCAL; don't worry.)"
18:55:56 <elliott> <elliott> where's ais when you need him
18:56:20 -!- derrik has joined.
18:56:21 <ais523> elliott: I don't expect them to have to use INTERCAL either
18:56:38 <kallisti> ais523: I've used that idiom in several languages actually.
18:56:59 <ais523> kallisti: most languages have a perfectly usable ternary
18:57:14 <ais523> OCaml has if/then/else; I imagine the same works in Haskell
18:57:32 <kallisti> !perl print (("kill self", "stay alive")[int(rand(6)) > 0])
18:57:33 <Sgeo> >deriv powerOfTwo x
18:57:38 <Sgeo> > deriv powerOfTwo x
18:57:39 <lambdabot> Couldn't match expected type `Data.Number.Dif.Dif b'
18:58:08 <kallisti> @let powerOfTwo = ap ((. (genericLength . nub . filterM (const [True, False]))) . ([id, recip] !!) . fromEnum . (< 0)) (enumFromTo 1 . abs)
18:58:28 <kallisti> > deriv powerOfTwo (x :: Expr)
18:58:44 <lambdabot> No instance for (GHC.Enum.Enum (Data.Number.Dif.Dif a))
18:59:46 <kallisti> > length . filterM (const [True, False] $ replicate 4 0
18:59:47 <lambdabot> <no location info>: parse error (possibly incorrect indentation)
18:59:52 <kallisti> > length . filterM (const [True, False]) $ replicate 4 0
19:01:10 -!- Phantom_Hoover has joined.
19:01:26 <kallisti> > let powerOfTwo n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . filterM (const [True, False]) $ replicate (abs n) Nothing] in powerOfTwo 4
19:01:27 <lambdabot> <no location info>: parse error on input `]'
19:01:33 <kallisti> > let powerOfTwo n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . filterM (const [True, False]) $ replicate (abs n) Nothing in powerOfTwo 4
19:01:38 <kallisti> > let powerOfTwo n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . filterM (const [True, False]) $ replicate (abs n) Nothing in powerOfTwo -4
19:01:38 <lambdabot> Overlapping instances for GHC.Show.Show (GHC.Types.Int -> a)
19:01:44 <kallisti> > let powerOfTwo n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . filterM (const [True, False]) $ replicate (abs n) Nothing in powerOfTwo (-4)
19:02:08 <kallisti> @let powerOfTwo n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . filterM (const [True, False]) $ replicate (abs n) Nothing
19:02:08 <lambdabot> Multiple declarations of `L.powerOfTwo'
19:02:13 <kallisti> @let powerOfTwo n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . filterM (const [True, False]) $ replicate (abs n) Nothing
19:02:23 <kallisti> > deriv powerOfTwo (x :: Expr)
19:02:24 <lambdabot> Couldn't match expected type `Data.Number.Dif.Dif a'
19:02:35 <lambdabot> forall a. (Fractional a) => Int -> a
19:03:16 <lambdabot> forall i a. (Integral i) => i -> a -> [a]
19:04:05 <kallisti> @let powerOfTwo n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . filterM (const [True, False]) $ genericReplicate (abs n) Nothing
19:04:18 <kallisti> > deriv powerOfTwo (x :: Expr)
19:04:19 <lambdabot> No instance for (GHC.Real.Integral
19:04:47 <kallisti> @hoogle (Integral a, Num b) => a -> b
19:04:47 <lambdabot> Prelude fromIntegral :: (Integral a, Num b) => a -> b
19:04:48 <lambdabot> Prelude (^) :: (Num a, Integral b) => a -> b -> a
19:04:48 <lambdabot> Data.List genericIndex :: Integral a => [b] -> a -> b
19:05:10 <kallisti> @hoogle (Integral a, Num b) => b -> a
19:05:10 <lambdabot> Prelude ceiling :: (RealFrac a, Integral b) => a -> b
19:05:10 <lambdabot> Prelude floor :: (RealFrac a, Integral b) => a -> b
19:05:10 <lambdabot> Prelude round :: (RealFrac a, Integral b) => a -> b
19:05:32 <lambdabot> No instance for (GHC.Real.Integral (Data.Number.Dif.Dif a))
19:07:17 <kallisti> @let powerOfTwo n = ([id,recip] !! (fromEnum (n < 0))) . genericLength . filterM (const [True, False]) $ genericReplicate (abs . floor $ n) Nothing
19:07:38 <kallisti> > deriv powerOfTwo (x :: Expr) -- Expr is /totally/ a RealFrac
19:07:39 <lambdabot> No instance for (GHC.Real.RealFrac SimpleReflect.Expr)
19:09:04 <elliott> > map (deriv powerOfTwo) [-5.5,-5..5]
19:09:06 <lambdabot> [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0....
19:09:19 <kallisti> elliott: I wonder where that's happening
19:09:50 <elliott> Your function isn't very... nice.
19:09:52 <kallisti> well calculating the length from replicate just gives you a bunch of 1 + 1 + 1 + 1 ...
19:09:53 <elliott> It has a conditional and all.
19:10:22 <kallisti> so that's probably why it's zero
19:12:38 <kallisti> elliott: what are you talking about this is definitely the best implementation of the base-2 real-except-actually-integer exponential function
19:14:09 <lambdabot> No instance for (GHC.Real.RealFrac GHC.Types.Int)
19:20:58 <kallisti> > let multiply x y = genericLength . concatMap ((const .: genericReplicate) x Nothing) $ replicate y Nothing in multiply 2 5
19:22:13 <kallisti> > let multiply x y = genericLength . concatMap ((const .: genericReplicate) x undefined) $ replicate y undefined in multiply 2 5
19:22:45 <kallisti> fromIntegral = (`genericReplicate` undefined)
19:23:27 <kallisti> only works for positive numbers
19:24:04 -!- oerjan has joined.
19:24:53 <kallisti> (+) = (++); (*) = concatMap . const;
19:25:05 <kallisti> haven't quite figured out subtraction. this really only works for positive numbers.
19:25:21 <oerjan> kallisti: (*) = (>>) too, iirc
19:25:21 <lambdabot> oerjan: You have 2 new messages. '/msg lambdabot @messages' to read them.
19:25:54 <kallisti> > length $ replicate 4 undefined >> replicate 5 undefined
19:26:38 <lambdabot> forall (m :: * -> *) a b. (Monad m) => m a -> m b -> m b
19:26:48 <kallisti> elliott: for lists... which is the context here.
19:26:55 <oerjan> and (^) = mapM . const
19:27:03 <lambdabot> forall a (m :: * -> *) b. (Monad m) => m b -> [a] -> m [b]
19:27:38 <kallisti> oerjan: well for powers of two I've been using filterM to compute the power set.
19:28:37 <kallisti> challenge: use this scheme to model negative numbers
19:29:00 <lambdabot> forall a (m :: * -> *) b. (Monad m) => m b -> [a] -> m ()
19:29:22 <oerjan> assuming you don't care about the element type
19:29:36 <kallisti> so far the element is undefined
19:29:39 <oerjan> > mapM_ (const [1,2,3]) [1,2]
19:30:06 <kallisti> so that the instance could be made for [a] instead of [()] or something
19:30:27 -!- Klisz has quit (Ping timeout: 244 seconds).
19:30:55 <kallisti> oerjan: I don't think this can work at all with negatives
19:31:07 <elliott> you can construct them with the obvious tuple formation
19:31:09 <oerjan> kallisti: you'd think :P
19:32:15 <kallisti> oerjan: oh, you missed the first part. fromIntegral = (`genericReplicate` undefined)
19:33:33 <kallisti> well Either [a] [a] could do negatives... but I don't think it would be very pretty.
19:34:05 <kallisti> also it suffers from negative zero
19:34:11 <oerjan> idea: let n = (replicate n undefined ++) and let -n = drop n
19:34:51 <elliott> that's the same way you (usually) construct the rationals
19:35:03 <lambdabot> forall i a. (Integral i) => i -> [a] -> [a]
19:35:07 <elliott> it has the same problem of infinitely many ways to represent any one given number
19:35:32 <kallisti> oerjan: unless we give it an integral instance. you'd want drop (length n)
19:35:55 <elliott> kallisti: that isn'tw hat he meant
19:35:59 <elliott> a = b means representation of a is b
19:36:14 <elliott> negate a = drop (length (a []))
19:36:27 <elliott> because it can't negate negatives
19:36:42 <elliott> because then you could do like
19:36:51 <oerjan> kallisti: er i was giving the translation from Ints, really
19:37:07 <elliott> > (const (drop 10)) 0 [1..]
19:37:08 <lambdabot> [11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35...
19:37:18 <elliott> > (\a -> (replicate 10 a ++)) 0 [1..]
19:37:20 <lambdabot> [0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,...
19:37:39 <elliott> (ofc that cheats by using Integer :P)
19:38:23 <oerjan> you figure out the details ;P
19:38:33 <elliott> oerjan: well yours _works_ fine.
19:39:00 * oerjan notes that yafgc updates aren't quite as regular as he's used to from his webcomics
19:39:18 <elliott> if null $ n [undefined] then head $ n LIST_OF_ALL_NATURALS_REPRESENTED_IN_THIS_WAY else drop . length $ n []
19:39:59 <oerjan> except for oots, which was awful of course
19:40:48 <Sgeo> I assume that you're referring to oots's update schedule, and not the content, when you call it "awful"
19:41:21 * kallisti wasn't aware that there was any reason to read anything other than homestuck.
19:41:54 <coppro> kallisti: what about #esoteric?
19:42:07 <kallisti> I don't actually read #esoteric
19:42:27 <ais523> elliott: I /still/ maintain my kallisti = Bjorn comparison
19:42:49 <elliott> but I wouldn't want to read a book about kallisti
19:42:58 <kallisti> ais523: I don't really get that comparison
19:43:06 <ais523> kallisti: you wouldn't
19:43:14 <kallisti> elliott: dude I'm super interesting.
19:43:25 -!- Klisz has joined.
19:43:27 <kallisti> a book about me would be amazing
19:43:27 <oerjan> elliott: regarding my anti-glogbot stance, i was actually using it at the time and somehow managed to think i was using tunes because insane timezones were involved
19:43:31 <kallisti> it would be the greatest work of literature.
19:44:16 <Sgeo> There's already a book about me, at http://codu.org/logs/_esoteric/
19:44:30 <Sgeo> (Note: Jokes aside, I have not in fact told my entire life story here)
19:45:00 <oerjan> indeed, only the embarrassing parts
19:45:55 <lambdabot> [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28...
19:46:15 <oerjan> kallisti: it actually works as replicate n undefined . drop (-n)
19:47:17 <kallisti> but it's not particularly elegant is it?
19:47:23 <kallisti> the representation: yes. the code: no
19:47:34 <oerjan> feel free to create twosided infinite lists :P
19:48:05 <kallisti> valid operation: flipItTurnWays
19:48:37 <oerjan> not WitherShins? (sp?)
19:48:59 <kallisti> that's not a joke I'm aware of
19:49:06 <kallisti> flipItTurnWays is much better.
19:49:29 <oerjan> oh well i misread that as TurnWise anyway
19:51:27 <kallisti> for two-way list things, toInteger = genericLength
19:51:41 <kallisti> as negative lengths would be possible.
19:56:57 <Sgeo> kallisti, go read some Discworld
20:11:24 <oerjan> <kallisti> I swear I can program guys. <-- NOOOO, don't program me!
20:14:15 <kallisti> > let x = dVar (var "oerjan") in deriv (\x -> x^2 + 2*x + 1) x
20:14:26 <oerjan> AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
20:14:30 <kallisti> > let x = var "oerjan" in deriv (\x -> x^2 + 2*x + 1) x
20:14:50 <kallisti> elliott: I made a cool thing earlier
20:16:34 <kallisti> > let nDerivs f = genericLength . takeWhile (/=0) . iterate df . f $ dVar (x :: Expr) in nDerivs (^2)
20:17:18 <kallisti> > let nDerivs f = genericLength . takeWhile (/=0) . iterate df . f $ dVar (x :: Expr) in nDerivs sin
20:17:23 <kallisti> > let nDerivs f = genericLength . takeWhile (/=0) . iterate df . f $ dVar (x :: Expr) in nDerivs (const 4)
20:18:34 <kallisti> actually just iterate df . f $ dVar x by itself is pretty cool.
20:18:59 <ais523> elliott: 4 spaces = 1 indent, 1 tab = 2 indents?
20:19:11 <kallisti> > iterate df . (^2) $ dVar (x :: Expr)
20:19:13 <lambdabot> [x * x~~,1 * x + x * 1~~,1 * 1 + 1 * 1~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~~,0~...
20:19:20 <elliott> indentation I set separately with sw=4 (although this is a flaw of vim that it's set like this)
20:19:21 <ais523> elliott: that's just broken
20:19:28 <kallisti> > map val . iterate df . sin $ dVar (x :: Expr)
20:19:30 <lambdabot> [sin x,1 * cos x,1 * (1 * negate (sin x)),1 * (1 * (1 * negate (cos x))),1 ...
20:19:35 * elliott continues using his broken editor happily.
20:20:08 <ais523> why is it a flaw of vim that it can set tabs and indentations differently?
20:20:25 <ais523> most editors can do that, to read code in the common indent = 2 spaces, 4 indents = 1 tab format
20:20:33 <ais523> (I know it's common because I've seen it in quite a lot of third-party code)
20:20:45 <Sgeo> On Linux, should I use emacs from the console or is a more graphical emacs acceptable?
20:20:47 <elliott> 2-spaces is not common in C outside of GNU code
20:20:55 <elliott> it is used, but not very commonly
20:21:05 <elliott> Sgeo: If you use a graphical Emacs, weasels will peck at your face.
20:21:05 <kallisti> Sgeo: only legitimate hackers use nano on console.
20:21:10 <elliott> And we will consider you inferior.
20:21:21 <HackEgo> 665) <shachaf> Real Tar is GNU tar. <shachaf> You just ignore whichever features don't make you feel superior enough.
20:22:43 <kallisti> @let nDerivs f = genericLength . takeWhile (/=0) . iterate df . f $ dVar (x :: Expr)
20:22:51 <ais523> elliott: I think 2-char-widths is the most common indentation I've seen for C
20:22:57 <ais523> whether via spaces or mixed space/tab
20:23:03 <ais523> although I see 4 from time to time
20:23:18 <ais523> and occasionally 8 when someone's used only tabs
20:23:49 <kallisti> elliott: clearly this is the most useful piece of Haskell code written, yes? (nDerivs)
20:24:02 <elliott> ais523: It's true that if you fudge the numbers with your unpopular opinions, then you can derive incorrect results, yes
20:24:28 <ais523> elliott: well, what width would you say code's using if it's indented only with tabs? serious question
20:24:52 <ais523> I think you either have to count it as 8, or ignore it altogether as if it's not 8, there's no information about what it's intended to be
20:24:58 <elliott> It's not, it's indentation-width agnostic. But what matters for statistics is whatever the majority of its authors uses.
20:25:15 <olsner> ooh, a tab-width discussion
20:25:20 <ais523> elliott: no, what the majority of its readers use
20:25:23 <elliott> olsner: no, i'm not giong to let it develop that far
20:25:36 <ais523> olsner: it's an indentation-width discussion, which is not quite the same thing
20:25:41 <kallisti> the width of a tab is the width of a tab.
20:25:58 <elliott> actually, I'm ending it here since this is boring
20:25:59 -!- GreaseMonkey has joined.
20:26:06 -!- GreaseMonkey has quit (Changing host).
20:26:06 -!- GreaseMonkey has joined.
20:26:07 <olsner> the file can specify a tab width through a modeline, thereby indicating its indentation width even if it's all just tabs
20:26:29 <ais523> olsner: I was thinking about that
20:26:32 <elliott> olsner: indeed (although the reader is of course not bound to it, it's just to make the developers' job easier)
20:26:36 <ais523> but modelines are getting increasingly rare nowadays
20:26:42 <elliott> olsner: actually i think that shoudln't be used at all
20:26:47 <elliott> because it overrides each developer's individual preference
20:26:50 <ais523> and arguably, if a file is tab-indented, the modeline should say it's tab-indented but not the size of a tab
20:27:55 <ais523> bleh, I was looking for statistics but couldn't find them
20:28:13 <ais523> I wonder if mixed spaces/tabs, in C, is more common than pure tabs
20:28:17 <ais523> it must be quite close, I imagine
20:28:28 <Gregor> elliott, ais523: The IOCCC submission page has an "additional authors" option.
20:28:33 <elliott> ais523: That term is ambiguous.
20:28:40 <ais523> elliott: right, just not public publishing
20:28:44 -!- zzo38 has joined.
20:28:59 <elliott> and nothing in the rules forbids public publishing
20:29:06 <olsner> I think mixed spaces and tabs is the most universally disliked indentation
20:29:10 <elliott> Gregor: They have a page? I thought you were meant to use their tool to generate a file to mail.
20:29:19 <ais523> elliott: hmm, has it changed? there definitely /was/ a rule about using publicly published stuff in a previous year
20:29:25 <ais523> elliott: no, there's a submission form nowadys
20:29:25 <olsner> unless you're just mixing styles haphazardly all around
20:29:29 <elliott> olsner: it's an ambiguous term; I bet ais523 would label tabs-for-indentation, spaces-for-alignment under that
20:29:35 <elliott> olsner: but that's the /reasonable/ way to use tabs
20:29:46 <Gregor> elliott: They appear to have a page, although the page may ultimately just say "OK, give these options to the tool", I haven't gone through the whole process yet.
20:29:51 <elliott> and the only tab-based indentation scheme anyone's advocated for years
20:30:21 <ais523> elliott: actually, I was planning to count tabs-for-indentation, spaces-for-alignment as pure-tabs
20:31:04 <ais523> although there are problems, such as if you want comments to line up in a correctly indented version of f(); /* comment */ if(x) { g(); /* comment */ h(); }
20:31:54 -!- lambdabot has quit (Ping timeout: 240 seconds).
20:32:17 <olsner> hmm, I generally dislike alignment
20:33:14 * elliott generally doesn't align too, but only because text sucks
20:33:26 <kallisti> I'm pretty OCD about aligning things properly.
20:33:33 <elliott> I don't want to align multiple lines in ()s unless I can make the parentheses as large as the lines.
20:33:50 <elliott> kallisti: aligning things like assignments is usually Wrong, because you never want to look at it like a table
20:33:54 <elliott> I'm talking about things like e.g.
20:34:06 <ais523> we need a Unicode character for flexible indentation
20:34:28 <elliott> ais523: U+??? ELASTIC TABSTOP?
20:34:28 <ais523> elliott: yep, that's easy to align correctly
20:34:33 <kallisti> elliott: well I usually align assignments based on similarity of purpose...
20:34:48 <kallisti> I just find it easier to read when they're aligned.
20:35:00 <elliott> ais523: the problem is that they aren't reducible to a character, I think
20:35:33 <elliott> ais523: one problem with elastic tabstops is that they force some visual space
20:35:37 <elliott> <elliott> int f(int x, int y, ...,
20:35:54 <elliott> I'm tempted to say that tabstops beyond the start of a line should have no space after their previous column
20:36:02 <elliott> so you use two spaces before eacht abstop if you want to space inline comments out
20:37:46 <elliott> ais523: but anyway, the tab character works for elastic tabstops as used in code
20:38:01 <elliott> since alignment should never really be semantically meaningful there, like it would be for a table, it degrades gracefully
20:38:51 <ais523> elliott: the problem is that the viewer would need to recognise it
20:39:06 <elliott> ais523: nah; using elastic tabstops to view files with old-style tabs works fine too
20:39:06 <ais523> and I often view code in things that aren't intended specifically for the purpose
20:39:25 <elliott> tabs at the beginning of the line still work fine, which is 99% of them
20:39:31 <ais523> elliott: are you going to change the entire installbase of everything - browsers, email clients, IRC clients, etc - to interpret tabs as elastic?
20:39:38 <elliott> ais523: you don't have to?
20:39:44 <elliott> elastic tabstops gracefully degrade
20:39:59 <ais523> no they don't, they line up the things you're elasticating wrong except at the start of a line
20:40:12 <ais523> also, are too wide at the start of a line
20:40:33 <ais523> because believe it or not, the vast majority of software currently interprets tabs as 8 regardless of whether you think that's right or not
20:41:41 <elliott> ais523: (a) that doesn't matter much; being slightly uglier but still making sense is the /definition/ of graceful degradation (b) troll
20:42:24 <ais523> elliott: but what I mean is, the vast majority of software in existence has no reason to start interpreting tab as meaning something different
20:42:44 <ais523> if you added it as a new Unicode character, though, they'd start interpreting it correctly over time
20:43:03 <ais523> elliott: Unicode support has got better over time, has it not?
20:43:16 <elliott> elastic tabstops are algorithmically non-trivial
20:43:28 <ais523> oh no, kerio's just started up with the ssh fanboyism again
20:43:52 <elliott> and "programmers who have compilers fancy enough to do elastic tabstops" is very niche
20:45:23 <ais523> elliott: OTOH, the whole thing that drives development of most programs is what programmers want
20:45:46 <elliott> that's one of the falsest things you've ever said
20:45:50 <elliott> and that's saying something
20:46:15 <ais523> elliott: hmm, I think I may be right if you don't allow for popularity
20:46:21 <ais523> most programs are written by programmers
20:46:37 <elliott> "most" over such a large, varied space without some kind of filtering is ridiculous
20:49:18 -!- elliott has quit (Remote host closed the connection).
20:49:54 -!- elliott has joined.
20:50:30 -!- derrik has quit (Quit: :)).
20:52:00 -!- lambdabot has joined.
20:57:10 <olsner> through newfangles like html5 video, presumably
20:57:53 <Sgeo> YouTube doesn't support HTML5 for all videos, I think
20:58:09 <Sgeo> Also, there's a way to enable individual flash elements usually
20:58:21 <Sgeo> If I didn't think of that, I'd ask how elliott would Homestuck
21:01:26 <ais523> kallisti: I use a different browser for YouTube (and other video sites) than I do from everything else
21:01:32 <ais523> that's the simplest solution
21:02:08 <kallisti> is having flash on by default really that big of a deal?
21:02:08 <ais523> there are others, of course
21:02:17 <ais523> (I also have a third browser, for accessing Google-related sites)
21:02:54 <oerjan> ais523 is clearly the reincarnation of rube goldberg
21:02:55 <GreaseMonkey> kallisti: well 99% of flash files are just for shitty ads
21:03:06 <kallisti> ah see I fix this by not having ads ever.
21:03:47 <ais523> oerjan: I also have a /fourth/ browser for accessing programming language documentation, but that's more about convenience than privacy
21:03:51 <ais523> also, IE6, for testing sites in IE6
21:06:18 <kallisti> I use this magical thing called adblock
21:09:04 <ais523> kallisti: it isn't magical; understanding it will make it better
21:09:11 <ais523> in particular, I use it to block quite a few things that aren't adverts
21:09:19 <ais523> it's a generic annoyance-blocker, for me
21:10:31 <kallisti> ais523: how and this whole time I thought it was voodoo
21:10:52 <HackEgo> 188) <fungot> elliott: i like scsh's mechanism best: it's most transparent and doesn't really serve a very useful feature. \ 191) <fungot> elliott: it's hard to debug havoc on your mirror if you accidentally hit r, then a character could be multiple words long, depending on the task. \ 200) <Gregor> elliott: My university has two Poultry Science buildings. <Gregor> Two! \ 209) <elliott> Vorpal loves the sodomy. <Vorpal>
21:11:09 <ais523> kallisti: it basically blocks images or elements by URLs or URL+rules for locating it on a page (ID, etc)
21:11:25 <oerjan> poor Gregor studying in such a fowl place
21:11:25 <ais523> but basically, you see something that annoys you (particularly an image), you just right-click on it and tell adblock to get rid of it
21:11:45 <oerjan> (what do you _mean_ i used that pun yesterday too?)
21:11:55 <ais523> oerjan: hmm, that indirectly reminds me of the day there was an enormous gas odoriser leak
21:12:05 <ais523> that caused a bit of chaos
21:13:08 * oerjan doesn't know what gas odoriser is, but imagines it's something you add to odorless poisonous gas in order to make it noticable
21:13:19 <oerjan> which would explain the chaos
21:13:32 <ais523> oerjan: not poisonous, it's added to methane
21:13:41 <ais523> because leaked methane is a huge fire risk
21:13:45 <oerjan> right, explosive would work too
21:16:50 <kallisti> this whole time I have been using AdBlock and had no clue how it operates, or the features it sports.
21:17:14 <ais523> bleh, I'd love this all to be non-sarcastic, but I can't imagine it is
21:18:04 <oerjan> this whole time I have been thinking kallisti only spoke in literally truth
21:18:09 <kallisti> ais523: no I really am just as stupid as you think I am. :P
21:19:34 <kallisti> oerjan: I was under the impression that every statement on IRC was truthfully spoken.
21:21:44 <oerjan> and also everyone always use perfect grammar
21:21:44 <kallisti> "A new study in the Journal of Sexual Medicine said that men who put their penises in animals have a higher likelihood of penis cancer. "
21:22:17 <oerjan> but who were the control group
21:22:19 <ais523> kallisti: cause or effect?
21:22:39 <elliott> ais523: penis cancer increases the chance of bestiality, yes
21:22:47 <kallisti> ais523: are you suggesting that people who develop penis cancer -- yes
21:22:54 <ais523> elliott: that's not /obviously/ false, right?
21:23:17 <kallisti> "A member of a pro-zoophilia group told The Huffington Post by email that the results of the study should prompt people to take precautions, like using a condom, when having sex with animals."
21:23:25 <oerjan> ais523: clearly this must be a proper study so it was obviously double-blind with neither the subject nor the experimenter knowing whether what they were fucking was an animal
21:23:38 <elliott> But it doesn't cure penis cancer if you do it that way!
21:23:51 <ais523> oerjan: hmm, what proportion of each group was female? I think I've noticed a potential skew in the statistics
21:24:14 <oerjan> surely this would have been noticed during peer review
21:24:29 <elliott> oerjan: no no, neither the subject nor the experimenter knew whether they had penis cancer or not
21:24:42 <kallisti> "We think that the intense and long-term SWA [sex with animals] practice could produce micro-traumas in the human penile tissue. The genital mucus membranes of animals could have different characteristics from human genitalia, and the animals' secretions are probably different from human fluids.
21:24:48 <kallisti> Perhaps animal tissues are less soft than ours, and non-human secretions would be toxic for us."
21:25:00 <elliott> oerjan: unfortunately many of the experimentors later died of this, having not received treatment
21:25:52 <elliott> "Perhaps animal tissues are less soft than ours" <-- this is false, see: toilet paper advets
21:25:56 * Sgeo remembers reading about fruit flies, or something, and I forget the exact details, but the male's semen could become toxic to the females
21:26:07 <elliott> puppies and koalas have soft tissues too
21:26:08 * kallisti googled for: mucus membrane goat vagina chemicals
21:26:11 <elliott> ais523: <kallisti> "We think that the intense and long-term SWA [sex with animals] practice could produce micro-traumas in the human penile tissue. The genital mucus membranes of animals could have different characteristics from human genitalia, and the animals' secretions are probably different from human fluids.
21:26:29 <elliott> * Sgeo remembers reading about fruit flies, or something, and I forget the exact details, but the male's semen could become toxic to the females
21:26:36 <elliott> Sgeo googled for: xxx fruit fly 18 or over
21:26:53 <kallisti> elliott: that was such a horrible joke.
21:27:01 <elliott> you're such a horrible joke
21:27:07 <ais523> fruit flies rarely live to 18
21:27:12 <kallisti> it crossed the so-horrible-it's-good coundary
21:27:13 <elliott> ais523: I was thinking of saying that
21:27:19 <oerjan> i recall that non-human mammals have barbed penises but this would be more a problem for bestial women, obviously
21:27:32 <ais523> elliott: I was actually going to make a joke along those lines earlier, but didn't have a good opportunity
21:27:35 <kallisti> oerjan: that's not a universal thing
21:27:38 <ais523> thanks for giving me one
21:27:49 <kallisti> oerjan: I know cats in particular have those.
21:27:59 <oerjan> kallisti: i vaguely thought nearly all mammals did
21:28:10 <ais523> whereas snails copulate by stabbing each other in the neck
21:28:59 <elliott> hmm, snail bestality doesn't sound like fun
21:29:12 <kallisti> oerjan: I think it's common in mammals anyway
21:29:59 <ais523> gah, now I have a huge urge to reference the hedgehog song
21:30:05 <ais523> so I will, and see who catches the reference
21:30:21 <oerjan> ais523: i cannot be bothered at all?
21:30:50 <ais523> oerjan: hmm, the original was a bit more vulgar, but that's close enough
21:31:04 <kallisti> oerjan: apparently the lack of a certain gene removes barbed penises and results in larger brains? or something?
21:31:19 <elliott> ais523: was that the reference?
21:31:28 <ais523> (on another note, I love the way that the standard way to indicate that you get a reference is to make a different obscure reference to the same thing)
21:31:39 <oerjan> ais523: oh, i only know it from some discworld books where it may have been bowdlerized
21:32:07 <ais523> I'm referencing the discworld books too, but it almost certainly /was/ bowdlerized in your version
21:32:14 <ais523> as that seems more likely than antibowdlerizing it in mine
21:32:26 <elliott> oerjan: http://www.lspace.org/fandom/songs/hedgehogsong.html
21:32:36 <oerjan> _or_ i may simply have misrembered the words
21:32:43 <ais523> elliott: I take it you searched rather than having the link mesmerized?
21:32:58 <elliott> ais523: My brain actually stores everything in URL form.
21:33:02 <elliott> For instance that previous line was
21:33:13 <elliott> http://ais523.elliott.i.take.it/you/searched?rather=than&having=the#link,mesmerized
21:33:16 <ais523> bonus points if you give a link to the logs for that line?
21:33:20 <elliott> I don't see what mesmerification has to do with it though.
21:33:30 <elliott> ais523: I never said they were /useful/ URLs
21:35:12 <ais523> now I'm wondering if that URL is valid, but don't want to click it just in case it is
21:35:15 <oerjan> kallisti: _or_ humans just improved on the bonobo culture by making it less painful
21:35:19 <ais523> take.it is almost certainly a valid domain
21:35:35 <ais523> but that doesn't say much about what it does with subdomains it doesn't recognise
21:35:39 <elliott> 404 - Questa pagina non esiste o è stata rinominata
21:35:54 <ais523> who 403s their homepage?
21:35:58 <oerjan> *bonobo-style, we're not their descendants...
21:36:04 <ais523> (besides, how do you log in if the homepage is 403?)
21:36:14 <ais523> (and you aren't using HTTP auth?)
21:36:28 <ais523> elliott: whatever causes it to stop 403ing
21:36:42 <ais523> most common 403 reason is lack of auth, isn't it?
21:36:51 <ais523> and you don't 403 an important page like a homepage unless there's some way to view it
21:36:54 <elliott> most common 403 reason is someone put 403 there
21:37:03 <elliott> e.g. a subdirectory that isn't meant to be web-exposed
21:37:13 <ais523> yep, but that doesn't apply to the homepage itself
21:37:17 <elliott> like internal files for some web application that exists in the web root
21:38:01 <ais523> yep, but they're unlikely to be called index.html
21:38:10 <kallisti> elliott: URLS should be graph-based instead of strictly trees.
21:38:21 <kallisti> I don't even know what that means exactly.
21:38:58 <kallisti> ais523: yes that is exactly 1 possibility in a set of infinite possibilities
21:39:44 <ais523> kallisti: if the probability really is 1/infinity, the likelihood can still be quite high
21:39:54 <oerjan> elliott: CONCRETE IS ALSO HARD
21:40:02 <ais523> (for likelihood, just think probability except that you multiply everything by infinity to get it back into non-infinitesimal units)
21:40:08 <ais523> (well, it's more complicated than that, but it always is, right?)
21:40:47 <ais523> kallisti: ordinary probabilities add to 1, right?
21:40:48 <oerjan> ais523: elliott isn't asking you to kick me, i'm disappoint
21:40:51 <ais523> likelihoods integrate to 1
21:41:02 <kallisti> ais523: are you just making stuff up
21:41:02 <ais523> oerjan: I thought concrete was more tough than hard
21:41:14 <ais523> it's a perfectly plausible thing
21:41:18 <ais523> for, say, probability distributions
21:41:24 <kallisti> right but do people call them likelihoods
21:41:29 <ais523> the chance of getting any particular real is 0
21:41:30 <kallisti> or is just, a... continuous probability distribution.
21:41:45 <ais523> and that name is used for them sometimes; I've heard "probability density" too, but it's a boring name
21:42:30 <kallisti> right well it's meaningless to talk about the probability of a single real in a continuous distribution
21:43:02 <oklopol> unless the measure has atoms
21:43:42 <oklopol> well atom is the term usually used in ergodic theory
21:43:54 <oklopol> and probably measure theory
21:44:14 <elliott> kallisti: http://en.wikipedia.org/wiki/Likelihood_function
21:44:15 <kallisti> seriously you have to making that up. -googles- oh, no.
21:44:32 -!- oklopol has changed nick to mathematician.
21:44:34 <elliott> [elliott@dinky ~]$ grep -r s2w .
21:44:35 <elliott> ./.bash_history:grep -r map_s2w .
21:44:58 -!- mathematician has changed nick to flyingdick.
21:47:41 <kallisti> flyingdick: oh my, I didn't realize your credentials. Excuse me for thinking (read: joking about how) ergodic sounds like a made up thing.
21:47:55 <ais523> oerjan: haha at whatever font you're using
21:47:58 <ais523> unless that was deliberate
21:47:59 <flyingdick> you're lucky i didn't kick you out of here
21:48:12 <oerjan> ais523: no i just need glasses, obviously
21:48:12 <elliott> hmm, why doesn't oklopol have op powers
21:48:13 -!- flyingdick has changed nick to oklopl.
21:48:14 <elliott> there's no way that could go badly
21:48:17 -!- oklopl has changed nick to oklopol.
21:48:21 <oklopol> sorry i was kind of a dick there
21:48:32 -!- elliott has changed nick to oklopl.
21:48:37 <oklopol> yeah i think i should have op powers
21:48:44 -!- oklopl has changed nick to elliott.
21:48:50 <elliott> yeah but seriously though give oklopol op powers
21:48:51 <oklopol> i would kick everyone who doesn't blindly accept everything i say
21:49:05 <elliott> oerjan: /msg chanserv #esoteric op oklopol, thanks
21:49:08 <oklopol> especially if they're right
21:49:08 <kallisti> elliott just likes to find excuses to kick me indirectly.
21:49:15 <oklopol> why would he want to kick you
21:49:45 <kallisti> BECAUSE THIS IS WHAT ELLIOTT DOES.
21:49:46 -!- Klisz has quit (Read error: Connection reset by peer).
21:49:57 <kallisti> like, if there were a typeclass called WantsKick
21:50:10 <kallisti> instance WantsKick Elliott Kallisti
21:50:13 <oerjan> elliott wants to kick us and hear the lamentations of our women, that just goes with the evil overlord thing
21:51:02 <oerjan> some here are actually _married_, unless they've been lying.
21:52:46 -!- Klisz has joined.
21:52:51 <kallisti> oerjan: I'd say the pairing graph for #esoteric is mostly edgeless.
21:53:56 <kallisti> In the area of graph theory in mathematics, a signed graph is a graph in which each edge has a positive or negative sign.
21:54:10 <oerjan> sign this graph, please
21:54:45 <kallisti> like... whatever the sign of zero is.
21:55:07 <kallisti> past edge = -, present edge = 0, future edge = +
21:55:31 <elliott> hmm, w2s can go eventually but we need it for now; s2w is used in multiple cases...
21:55:48 <elliott> but i don't really want _two_ functions to do the same thing
21:57:23 <kallisti> elliott: I thought the Haskell slogan was "there's more than one function to do it"
21:58:14 <oerjan> yeah haskell only has the bare minimum, like map, fmap, (.), liftA, liftM and (<$>).
21:58:26 <ais523> how is (.) like map/fmap?
21:58:38 <oerjan> ais523: (e ->) instance
21:58:41 <lambdabot> forall a b (f :: * -> *). (Functor f) => (a -> b) -> f a -> f b
21:59:45 <ais523> I thought (.) was function composition; is that a special case of a general definition?
22:00:18 <Sgeo> kallisti, when have I ever trolled you about updates?
22:00:40 <kallisti> Sgeo: why would you confuse yourself with me?
22:00:44 <kallisti> clearly I am doing the trolling.
22:01:01 <Sgeo> I just wish I knew why you were doing it
22:01:18 <kallisti> Sgeo: it's because I love you. :3
22:01:20 <oerjan> ais523: that's cale's idea of letting lambdabot have generalized versions of standard functions
22:01:28 <lambdabot> forall m. (Monoid m) => m -> m -> m
22:01:32 <lambdabot> forall (f :: * -> *) a b. (Functor f) => f (a -> b) -> a -> f b
22:02:06 <ais523> ++ on Monoids disturbs me
22:02:25 <elliott> (++) should obviously be generalised to monoids
22:02:26 <ais523> mostly because the monoid version of ++ is mostly just coincidence that append is the most appropriate operation on lists
22:02:35 <ais523> elliott: yes, agreed; I just disagree with ++ being the name for that
22:02:43 <elliott> ais523: then you disagree, and misread my statement
22:02:44 <oerjan> ais523: that's what it was like in haskell 1.4, i think, or maybe it was MonadPlus.
22:03:01 * elliott would rather remove (++) and make (<>) the monoid operation
22:03:06 <ais523> elliott: I'd be fine with that
22:03:23 <kallisti> ++ could be MonadPlus and <> could be Monoid
22:03:35 <elliott> ais523: (++) doesn't inherently mean append.
22:03:52 <elliott> kallisti: MonadPlus needs to go away
22:04:03 <ais523> OCaml uses @ for list append (and its operators aren't polymorphic), I was interesting that it had a one-char name for something that specific
22:04:09 <kallisti> elliott: I disagree, we should have two more of them, and two more Monoids
22:04:16 <elliott> although I guess it's nice to have with MonadZero, which is nice because you don't need a constraint per a
22:04:34 <elliott> ais523: you was interesting?
22:04:38 <kallisti> elliott: also n-parameter monoids, for monoids with two type parameters and more.
22:04:53 <ais523> also, *you were interesting?
22:05:02 <elliott> no, you was definitely interesting
22:05:05 <ais523> grammar transformations of bad grammar has rules!
22:08:06 <ais523> elliott: yep, I Muphried myself somewhat there
22:08:15 <ais523> which is strange, as I mostly don't get caught in Muphry's Law
22:09:17 <HackEgo> Monoids are just categories with a single object.
22:09:20 <elliott> ais523: oh, oops, i was trying to make it incorrect
22:09:49 <kallisti> elliott: they've... Facebookitized it.
22:09:55 <ais523> elliott: what, /again/?
22:10:17 <kallisti> elliott: they're using a similar layout to what facebookuses
22:10:24 <elliott> chrome users: is chrome adblock or adblock plus for chrome better?
22:10:28 <elliott> and can either block youtube video ads?
22:10:55 <kallisti> I dunno anything about chrome adblock
22:11:04 <elliott> it's just called "adblock"
22:11:04 <kallisti> I sometimes forget the internet has ads.
22:11:15 <elliott> it's more popular than adblock plus, though probably only because it's older
22:11:31 <elliott> ofc adblock plus is the most popular extension for any browser
22:11:36 <elliott> but the codebase is different for chrome, so :P
22:11:40 <kallisti> elliott: no I'm using Adblock apparently
22:11:54 <elliott> kallisti: right. not the same thing, it rides on having a similar name to the unrelated Firefox extension...
22:12:02 <elliott> Adblock Plus is the official port
22:12:32 <elliott> that's what I just wondered.
22:13:29 -!- Ngevd has joined.
22:14:04 -!- Phantom_Hoover has quit (Ping timeout: 244 seconds).
22:14:07 <Ngevd> I never did figure out where to put that patch
22:14:10 <elliott> looks like adblock plus uses the same filtering engine as the firefox version's
22:14:19 <Ngevd> For Dungeons of Drednor
22:15:15 <kallisti> elliott: reviews for Adblock Plus seem to suggest that it is better
22:15:37 <elliott> "Sorry, but i thinks it works fine. I have NO adds on any site. and it is still much faster than addblock! adblock (that without plus) slows down every webpage i visit. ABP ist still "the same" like adthwart (only the laughing devil i miss :) )" ;; this person seems too stupid to trust
22:15:39 -!- boily has quit (Quit: WeeChat 0.3.6).
22:16:27 <kallisti> elliott: it's a good thing you consulted an expert opinion
22:16:57 <elliott> "Block ads inside YouTube videos" yay
22:17:27 -!- Jafet has quit (Quit: Leaving.).
22:18:00 <kallisti> they both more or less use the same filters.
22:18:08 <kallisti> though Adblock seems to have more foreign language filters in the checklist
22:18:15 <oklopol> CHAINSAW EVERYONE AND CHAINSAW EVERYTHING
22:18:25 <elliott> oklopol: i agree, someone op oklopol
22:18:58 <oklopol> well really i deserve ops, i've been here longer than anyone else
22:19:00 <ais523> elliott: just because someone's stupid doesn't mean they're wrong
22:19:32 <elliott> ais523: very true, but they don't seem articulate enough about their technical experience to have judged it correctly
22:19:48 <ais523> yep, so if they're right, it's by chance
22:19:51 <elliott> and "Sorry, but i thinks it works fine." seems to imply it's a reaction to a negative review, which makes me trust it less
22:21:17 <elliott> olsner: You use vim, right
22:21:41 <ais523> olsner: do you move with vikeys or numpad?
22:21:43 <elliott> olsner: What indentation style do you use
22:22:04 <elliott> oh, numpad has arrow keys without numlock
22:22:06 <olsner> ais523: usually arrow keys :>
22:22:08 <elliott> you can't go diagonally though
22:22:15 <ais523> elliott: the discussion came up in #nethack recently, and someone said they used numpad for vim but vikeys for nethack
22:22:39 <elliott> olsner: <elliott> olsner: What indentation style do you use
22:22:53 <ais523> elliott: I don't think so
22:23:08 <kallisti> elliott: I use tabs as though there spaces.
22:23:10 <elliott> ais523: what was kerio ssh-fanboying about, btw?
22:23:18 <olsner> let's see... sw=4 ts=4 sts=4 noet cinoptions={0,:0,t0,g0,^0,e0,n0,p2s,(2s,f0 cinkeys=0{,0},0),:,0#,!^F,o,O,e
22:23:25 <elliott> olsner: no, that was a non-vim question :)
22:23:30 <olsner> I guess that's the relevant part of my vimrc for indentation style
22:23:46 <kallisti> vim scares me more than emacs.
22:23:50 <ais523> I actually know at least one person, probably more, who's a casual vim fanboy (think offhand Emacs-bashing and using vim at every opportunity) yet spends their time moving around with the arrows in insert mode
22:24:11 <ais523> elliott: and asking if there was an ssh port for the amiga, when the topic came up about how good it was at playing nethack
22:24:19 <elliott> ais523: I can yell at them for you, if you'd like
22:24:30 <ais523> topic's changed, unfortunately
22:24:34 <ais523> you could yell at him on general principles
22:24:35 <elliott> <ais523> I actually know at least one person, probably more, who's a casual vim fanboy (think offhand Emacs-bashing and using vim at every opportunity) yet spends their time moving around with the arrows in insert mode
22:24:42 <ais523> that's real-life knowing
22:24:47 <ais523> so you'd have to come to Birmingham
22:24:53 <kallisti> ais523: I do quite a bit of arrow-moving in Emacs when I probably could avoid it sometimes.
22:24:56 * elliott adds to "list of reasons to avoid birmingham"
22:25:05 -!- Phantom_Hoover has joined.
22:25:29 <ais523> the person I have in mind is my other boss (I have two part-time jobs, he's the boss for half the teaching one rather than Dan who's the boss for the other half + the PhD)
22:25:35 -!- pikhq has joined.
22:25:52 -!- pikhq_ has quit (Read error: Operation timed out).
22:26:02 -!- Ngevd has quit (Quit: dredmor time).
22:26:24 <ais523> hmm, is Dredmor good enough that I should buy it, I wonder? opinions of the channel?
22:26:26 <ais523> and how much time is left?
22:26:44 <kallisti> elliott: oh and google has once again changed
22:26:55 <olsner> elliott: I never learned what the style is called
22:26:59 <elliott> ais523: I haven't played it yet, but have you played any introversion games?
22:27:03 <olsner> but the one with braces on their own lines and unindented, tab indented, tabs at 4 spaces (obv. works fine for other tab widths...)
22:27:08 <ais523> I'm not sure; probably not
22:27:17 <ais523> unless I've played one without mentally noting the developer, which is possible
22:27:29 <olsner> elliott: no, I just indent continuations by one or two indents
22:27:35 <kallisti> olsner: I prefer the open brace on the same line as the statement
22:27:41 <elliott> ais523: Uplink is amazing, Darwinia is meant to be even more amazing but I haven't played it yet, DEFCON is cool
22:27:48 <oklopol> ais523: DID YOU SEND A PAPER TO STACS
22:27:56 <ais523> oklopol: I don't think so
22:28:12 -!- oerjan has quit (Quit: Good night).
22:28:20 <oklopol> do you know stacs? i suppose it might be for more theoretical stuff than yours
22:28:31 <ais523> elliott: gah, they sent me an email in Markdown, that's almost enough to boycott them
22:28:44 <elliott> ais523: err, Markdown was intended to be suitable for emails
22:28:48 -!- Patashu has joined.
22:29:08 <ais523> elliott: Humble Bundle
22:29:15 <kallisti> elliott: it would be cool if df allowed you to have more control over how your soldiers fight
22:29:16 <ais523> and () around URLs is just so ugly
22:29:19 * elliott receives those as HTML mail
22:29:22 <kallisti> elliott: maybe with like... scripts.
22:29:27 <elliott> ais523: that's why you use the alternate link syntax
22:29:35 <ais523> elliott: that one was using []()
22:29:36 <olsner> elliott: have I answered your question now? :)
22:29:39 <kallisti> that you can turn on and off. like "fighting styles"
22:29:43 <ais523> is /that/ enough of a reason to hate the email?
22:29:44 <elliott> olsner: yes, unfortuantely it means you're useless
22:30:23 <olsner> oh noes! he said I'm useless
22:31:00 <oklopol> olsner you know you alright.
22:31:04 <kallisti> useless sounds fun when you pronounce the use as though it were the verb use
22:31:41 -!- Klisz has quit (Ping timeout: 248 seconds).
22:31:48 -!- Klisz has joined.
22:31:53 <ais523> gah, seems that Amazon is memorizing my credit card number too
22:32:04 <olsner> elliott: what use did you hope to have of me?
22:32:06 <ais523> in /addition/ to running no security checks on the card number
22:32:09 <oklopol> well isn't that nice, you don't have to give it to them every time
22:32:12 <kallisti> ais523: it just /really/ wants everything to be convenient for you doesn't it?
22:32:28 <elliott> olsner: if you used tabs-for-indentation-spaces-for-alignment and vim
22:32:45 <ais523> kallisti: it's reasonable from Amazon's point of view, but not from the bank's
22:32:50 <kallisti> elliott: I use all-spaces, out of habit from my Python days.
22:33:05 <elliott> kallisti: you also don't use vim afaik
22:33:16 <kallisti> elliott: what makes vim important here?
22:33:18 <olsner> I think I've only seen alignmentism together with fundamentalist spaceism
22:33:42 <kallisti> elliott: wow you have amazing deduction skills.
22:35:19 <olsner> oh well, I believe it has become DS9 time again
22:35:25 <kallisti> olsner: is "alignmentism" kind of like "being really OCD about aligning things"?
22:35:59 <kallisti> I might switch to tabs though. it makes more sense to me.
22:36:15 <kallisti> tab-indents with spaces for alignment
22:36:16 <olsner> kallisti: something like that yes
22:36:40 <ais523> elliott: I'm also considering boycotting Introversion for making every single image on their webpage set a cookie
22:37:43 <ais523> kallisti: there is no reason to set a cookie in more than one image from the same domain in a page
22:37:57 <ais523> and it aggravates people who approve/disapprove all cookies manually
22:38:02 <kallisti> I too am really concerned about this common nearly unavoidable feature of modern websites.
22:38:12 <kallisti> ais523: maybe you shouldn't do that. that sounds terrible.
22:38:14 <ais523> kallisti: cookies can be useful, when they have a reason to exist
22:38:28 <kallisti> like, basically every webpage starts with you clicking a bunch of dialogs right?
22:38:34 <ais523> the only sensible use of setting a cookie in an image that I've seen is Wikimedia's cross-site logon thing, though
22:38:42 <ais523> kallisti: far from every, maybe about 5-10%
22:38:53 <ais523> most of them are well-designed cookie-wise, and only require a couple of allow/deny
22:39:14 <ais523> quite a lot of sites set two cookies then modify one; I think it's some sort of anti-bot mechanism
22:40:23 <ais523> elliott: hmm, Uplink's premise seems very mindlessly destructive
22:40:33 <ais523> all the Introversion advertising just implies to me "this is not the sort of game ais523 would enjoy"
22:40:47 * elliott has never once looked at the advertising.
22:41:07 * kallisti has adblock installed in his brain.
22:41:32 <kallisti> if I go to the mall, then the people trying to advertise stores just disappear when they start talking to me.
22:41:46 <Sgeo> I'd say only 99% is mindless destruction
22:41:52 <kallisti> (note: I don't actually go to the mall, but it's happened before)
22:42:01 <elliott> ais523: anyway, Darwinia is one of the best-reviewed games I've ever heard of, if that means anything
22:42:07 <kallisti> ais523: best game ever is magicka
22:42:14 <ais523> I suppose I'd prefer to trust reviewers I trust
22:42:20 <Sgeo> elliott, is it safe to say that 1% of Uplink is NOT mindless destruction?
22:42:29 <ais523> I bought Advance Wars based entirely on the recommendation of Teletext's computer game review column
22:42:35 <ais523> and then went and bought all its sequels
22:42:37 <kallisti> magicka is 100% careful deliberate mindless destruction
22:42:40 <elliott> Uplink would be hard to play if you just mindlessly destroyed thinsg.
22:42:47 <elliott> Generally people who want files stolen don't want you just to trash a machine.
22:42:58 <Sgeo> elliott, I'm in particular referring to plot
22:43:01 <Phantom_Hoover> <Sgeo> elliott, is it safe to say that 1% of Uplink is NOT mindless destruction?
22:43:20 <elliott> Sgeo: Umm, not the Arunmor storyline?
22:43:25 <Phantom_Hoover> It's more than possible to go through the game having never deleted anything, although I think the story does require it.
22:43:31 <Sgeo> elliott, I was referring to that in particular
22:43:38 <elliott> "Half the plot" = 1% of the game
22:44:05 <Phantom_Hoover> ISTR that the Arunmor storyline requires at least one destructive attack.
22:44:13 <kallisti> elliott: didn't you know that plot is only like 2% of a game?
22:44:34 <Sgeo> ais523, there you go. Half the plot, minus a bit, is not mindless destruction
22:45:03 <kallisti> magicka is probably better than uplink
22:45:09 <elliott> ais523: anyway, even if the /idea/ is mindless destruction, the gameplay isn't
22:45:10 <kallisti> I base this on my extensive knowlege of uplink
22:46:02 <Phantom_Hoover> It requires that you destroy Arunmor's ISM as a false flag operation, but that's hardly mindless destruction.
22:46:13 <kallisti> GAH SPOILERS EVERYTHING IS RUINED
22:46:41 <elliott> Honestly, hardly any of Uplink is mindless destruction.
22:46:59 <elliott> It's not like even Andromeda hire you to FUCK SHIT UP.
22:49:05 <Sgeo> I can't even seem to get started with Darwinia
22:49:15 * Sgeo sucks at Darwinia. Can barely do the tutorial
22:49:48 <Phantom_Hoover> The level which consists of "create squad, right click until virii are gone."
22:50:10 <kallisti> Sgeo: don't ever play starcraft.
22:51:51 <Sgeo> The virii keep killing my squad
22:52:12 <Sgeo> It took a while before I worked out that I needed to make a squad
22:52:22 * Sgeo is easily amused by the Darwinia intros
22:52:28 <Phantom_Hoover> Sgeo, did you know that there are these things called ranged attacks.
22:52:46 <Phantom_Hoover> You can use them to pick the virii off before they get near enough to damage your squad.
22:53:42 <ais523> Phantom_Hoover: real-time strategy?
22:54:19 <Phantom_Hoover> Darwinian control is RTS, but I still haven't reached the point where that's meant to come in.
22:54:28 <kallisti> I think I just came up with the worst game idea ever: Mario Party MMO
22:55:33 * Sgeo decides that playing Darwinia windowed is not feasible
22:56:52 <ais523> Phantom_Hoover: a mixture with which?
22:57:10 <ais523> kallisti: there's a game mode in Pokémon HeartGold/SoulSilver which is pretty much exactly that
22:57:11 <Sgeo> Yay wireless headphones
22:57:14 <ais523> but with Pokémon instead
22:57:50 <Phantom_Hoover> ais523, you directly control squads by left clicking on destinations and right clicking to fire.
22:58:22 <ais523> hmm, like an RTS except requiring more micromanagement
22:58:27 <Phantom_Hoover> You control Darwinians by promoting one of them to an officer, and controlling that through a similar method to a squad, except all the commands tell the Darwinians where to go.
22:58:51 <Phantom_Hoover> Not really; it's designed so you only use one squad at a time.
22:59:41 <ais523> bleh, my TV Tropes links-clicked-per-page rate is now sufficiently below 1 that I can never stay there very long
23:00:18 <Phantom_Hoover> ais523, probably the best way to see what the gameplay's like is just to play the first level, which is short and extremely easy if you're not Sgeo.
23:00:27 <coppro> ais523: which mode is the mario party mmo?
23:00:28 -!- Phantom_Hoover has quit (Quit: Leaving).
23:00:31 <ais523> but that'd mean downloading and installign and running the game
23:00:40 <elliott> olsner: is there a way to stop vim from creating the .swp files
23:00:44 <ais523> coppro: oh, I've forgotten what it's called, but it has Poké Floats in it
23:00:47 <elliott> i keep getting OMG SWAP FILE when i open a vim
23:00:54 <kallisti> ais523: that's pretty much exactly how starcraft works. left click to move right click to fire.
23:01:13 <coppro> ais523: that's a smash bros stage
23:01:36 <ais523> coppro: I know, it's based on the Pokémon game mode (all smash bros stages but final destination are references to /something/)
23:02:11 <kallisti> Hanenbow I don't think is a reference to anything in the Nintendo universe.
23:02:19 <kallisti> but it's kind of a special stage.
23:02:28 <kallisti> also, just to nitpick, Battlefield isn't based on anything.
23:03:22 <kallisti> Hanenbow (pronounced Hay-nin-bow) is a new unlockable stage in Super Smash Bros. Brawl. It comes from a music-themed Nintendo DS game, which features extensive interactivity with the microphone; called Electroplankton.
23:03:38 <ais523> coppro: found it: Wi-fi Plaza
23:03:48 <ais523> http://bulbapedia.bulbagarden.net/wiki/Wi-Fi_Plaza
23:05:22 <ais523> elliott: use Maybe () instead?
23:05:39 <kallisti> elliott: use const and flip const instead.
23:05:46 <elliott> those are just church booleans!
23:07:14 <ais523> elliott: OK, use 1 and 2 then, and make it arbitrary which is true and which is false depending on what you want to use them for
23:07:30 <elliott> these are all just different representations of booleans ;P
23:07:48 <ais523> elliott: OK, then, use 01XLHWU-
23:08:00 <ais523> hmm, I've probably forgotten a possible value there
23:08:02 <kallisti> elliott: use Maybe Bool instead
23:08:02 <elliott> "The ulimit -v command can be used with ASan-ified binaries. However, you should remember that ASan consumes 16 terabytes of virtual memory for shadow state and the ulimit -v value should be set accordingly."
23:08:13 <kallisti> elliott: three-value logic ftw
23:08:26 <kallisti> elliott: or use integers for many-valued logic!!!
23:08:29 <ais523> kallisti: VHDL std_logic beats three-value logic out the water
23:08:45 <ais523> it models error conditions for booleans as well as the usual values 0 and 1
23:09:41 <ais523> not quite; U means unknown state at power on, - means a value that's being disregarded (i.e. don't know and don't care)
23:09:52 <ais523> either is a reasonable description of unknown
23:11:11 <MDude> Are any of them mu?
23:11:34 <kallisti> elliott: if you solve the halting problem you can just use terminate and non-terminate
23:11:48 <elliott> that's another representation of a boolean!
23:11:55 <MDude> Well yes, it's not boolean, that's why it's included~
23:12:03 <kallisti> elliott: I'm not sure I understand what you want to replace booleans with then.
23:12:04 <ais523> MDude: nope, the problem with mu is that it unasks the question, and the hardware equivalent would be sending electrons in the other direction
23:12:16 <ais523> except that typically, electrons flow one way for true and the other way for false
23:12:40 <elliott> kallisti: I never even said I wanted to, I just said I hate booleans
23:13:42 <MDude> I thought mu was more just "your question is stupid presumes something that is wrong".
23:13:51 -!- Klisz has quit (Quit: You are now graced with my absence.).
23:13:56 <elliott> your grammar is stupid presumes something that is wrong :D
23:14:00 <ais523> <NetHackWiki> The most important thing to remember is: Don't Panic. Or at least, panic at your leisure.
23:14:06 * Sgeo remembers a post on Less Wrong
23:14:46 -!- Klisz has joined.
23:14:52 <kallisti> elliott: dude I just figured out natural language
23:15:00 <kallisti> so basically you use a clever evaluation strategy.
23:15:16 <kallisti> for example: "your mom" evaluates to the value "your mom"
23:15:28 <kallisti> which can then be composed with other expressions
23:15:54 <Sgeo> http://lesswrong.com/lw/po/three_dialogues_on_identity/
23:16:02 <elliott> ais523: quick, should I worry about a duplicate hashtable lookup?
23:16:25 <ais523> elliott: if you're not using a cryptosecure hash, yes
23:16:35 <ais523> you're going to get collisions in practice
23:16:47 <ais523> it's OK to use an inefficient resolution mechanism unless you have a very small hashtable, though
23:17:01 <ais523> elliott: I don't think anyone uses cryptohashes for hash tables
23:17:10 <ais523> but, you never know, with enough memory/disk space you /could/
23:17:33 -!- sebbu has quit (Ping timeout: 248 seconds).
23:17:36 <elliott> ais523: are you sure you haven't misread my statement?
23:17:36 <ais523> and for something like git/sg's stores by hash, it makes sense
23:17:46 <elliott> ais523: try looking at it again
23:17:58 <ais523> I'm having difficulty parsing "duplicate hashtable lookup"
23:18:23 <elliott> aka two identical hashtable lookups to do one operation
23:20:41 <elliott> oh dear, I killed the wrong chromium proecss
23:22:44 <ais523> it can recover, right?
23:23:50 <ais523> elliott: if Firefox gets accidentally killed, even the whole thing, it can go back to the point it was at upon restart
23:24:02 <ais523> often with a confirmation in case one of the pages crashes it again
23:24:17 <ais523> yep, that's what I was referring to, I'd be shocked if Chrome couldn't
23:27:10 -!- sebbu has joined.
23:27:10 -!- sebbu has quit (Changing host).
23:27:11 -!- sebbu has joined.
23:28:20 <elliott> ais523: pls reassure me that hashtable lookups are fast
23:28:34 <ais523> elliott: they're almost as fast as array lookups on modern processors
23:29:29 <elliott> ais523: but that's one, two, three, four, five -- five array lookups in total!! five duplicated array lookups!
23:30:10 <ais523> elliott: wow, I wouldn't have expected /you/ to reference Sesame Street
23:30:35 <pikhq> Was that even aired in the UK?
23:30:38 <ais523> (which was recentishly in the news because someone hacked their YouTube channel to show hardcore porn)
23:30:41 <ais523> pikhq: indeed, on Channel 4
23:30:51 * elliott wasn't doing it intentionally, but I think there was some kind of ... subconscious resonant recognition before he hit enter.
23:31:07 <elliott> I was actually counting them out.
23:31:19 <elliott> pikhq: doesn't sesame street air /everywhere/? (also, "was"?)
23:31:39 <ais523> elliott: I'm not sure if it still airs nowadays in the UK
23:31:42 <ais523> admittedly, I haven't checked for years
23:32:44 <pikhq> elliott: Eh, could be. I'm not in the habit of monitoring where children's programming is aired.
23:33:19 <elliott> /* relies on implementation-defined arithmetic shift behaviour */
23:33:20 <elliott> I like how I leave comments for things like this but gleefully name new types foo_t
23:35:34 <elliott> bool world_handle_chunk(jint x0, jint y0, jint z0, jint xs, jint ys, jint zs, struct buffer zb, struct buffer zb_meta, struct buffer zb_light_blocks, struct buffer zb_light_sky, bool update_map);
23:35:40 <elliott> I can't help but feel this function needs a few more parameters.
23:36:34 <pikhq> bool world_handle_chunk(struct world_handle_chunk_args); There you go.
23:36:34 <elliott> wait, why is it never called with the last parameter set to false...
23:37:18 <pikhq> And then you can call it with world_handle_chunk((struct world_handle_chunk_args){ ... })
23:37:30 <pikhq> (pointless unless you want a lot of things to be 0, of course)
23:43:29 -!- MSleep has joined.
23:45:49 -!- ais523 has quit (Ping timeout: 248 seconds).
23:46:53 -!- MDude has quit (Ping timeout: 248 seconds).