←2011-07-26 2011-07-27 2011-07-28→ ↑2011 ↑all
00:04:14 -!- copumpkin has joined.
00:15:04 -!- olsner has quit (Ping timeout: 260 seconds).
00:18:21 <elliott> robots---->
00:18:57 <oerjan> IT HAS BEGUN?
00:19:06 -!- NihilistDandy has joined.
00:21:06 <Sgeo> In man against machine, machine will conquer all
00:21:15 -!- elliott has quit (Remote host closed the connection).
00:21:32 <NihilistDandy> Until the Butlerian Jihad, that is
00:21:45 -!- elliott has joined.
00:22:33 <Zwaarddijk> dune is kinda hegelian dialectic
00:22:36 <elliott> 23:41:56: <cheater_> if i have n regexes, is it possible to compile them all into one optimized thing that will match if either one had matched?
00:22:37 <elliott> 23:42:03: <cheater_> like a big or operator
00:22:39 <elliott> a|b|c|d
00:23:05 <Zwaarddijk> thesis: machines rule, antithesis: humans rule, synthesis: they coexist
00:23:13 -!- jcp has quit (Ping timeout: 260 seconds).
00:23:41 <Zwaarddijk> MARX IN SPACE
00:23:52 -!- variable has joined.
00:23:56 <NihilistDandy> Zwaarddijk: Except for the part where they don't really coexist and instead enslave and destroy one another most of the time
00:23:56 <elliott> 00:43:32: <CakeProphet> hmmm, so doesn't the fact that humans are reasonably effective at solving the halting problem for a given language suggest that it's impossible to replicate human intelligence via Turing-complete computation?
00:24:13 <elliott> CakeProphet: we are terrible at solving the halting problem, and obviously turing machines can solve a subset of the halting problem
00:24:16 <Zwaarddijk> NihilistDandy: read the sequel the son of Herbert's wrote?
00:24:28 <elliott> 00:44:34: <CakeProphet> well, I suppose since we're not perfect at it, and we can't solve it for languages that are unknown to us..
00:24:29 <elliott> "not perfect" -- you're way too kind to human intelligence :P
00:24:43 <NihilistDandy> Zwaarddijk: Not yet. Still getting through those. Just doesn't feel the same.
00:25:21 <Zwaarddijk> yeah I know.
00:25:26 <Zwaarddijk> they do suck
00:25:51 -!- jcp|other has quit (Ping timeout: 276 seconds).
00:25:53 <Zwaarddijk> and they kinda change feeling, and the end plot changes are kind of orthogonal in story space to any good endings
00:26:02 <Zwaarddijk> er, well, you get what I'm trying to say
00:26:07 <NihilistDandy> Yes. Yes I do
00:26:14 <Zwaarddijk> I am a bit disappointed at how it turns out
00:26:21 <Zwaarddijk> I liked the rabbis-in-space, though
00:26:34 <NihilistDandy> :D
00:26:49 <Zwaarddijk> those were kind of a wtf moment
00:27:14 <Zwaarddijk> this bene gesserit thingy where they go and say something like 'oh, we collaborate at times with an even older conspiracy'
00:27:14 <elliott> 04:12:03: <Sgeo> So what' are "true but unprovable" statements for a system of axioms?
00:27:15 <elliott> 04:12:10: <Sgeo> Or does that not apply to CH?
00:27:16 <elliott> 04:12:51: <oerjan> there is no such thing, truth only applies _inside_ a model of the axioms, unless it holds for _all_ models, in which case its provable.
00:27:27 <elliott> oerjan: well a lot of people natter about "true but unprovable" things, perhaps even people with skill, decades back, I presume...
00:27:36 <elliott> it is bandied about casually quite a bit
00:28:00 <elliott> 04:24:20: <oerjan> and i'm not entirely sure if there are some systems weaker than peano arithmetic (weak enough not to allow godel's proof) but still expressive enough to talk about their own consistency, and then maybe prove it.
00:28:01 <elliott> oerjan: yes IIRC
00:28:03 <elliott> oerjan: it doesn't have induction, I think
00:28:07 <NihilistDandy> Zwaarddijk: olawd
00:28:50 <NihilistDandy> elliott: Jesus, hitting your backlog hard enough?
00:29:05 <elliott> NihilistDandy: you realise i do complete logreads, right :D
00:29:17 <elliott> oerjan even does a lot of the time, though he replies rather less :P
00:29:27 <NihilistDandy> > elliott sleep
00:29:27 <lambdabot> Not in scope: `elliott'Not in scope: `sleep'
00:29:33 <NihilistDandy> Ah, that explains it
00:29:38 <oerjan> actually it's more of a complete logbrowse at best
00:29:49 <elliott> oerjan: you're dead to me
00:30:24 <NihilistDandy> Also, I missed a lot of good conversation
00:30:39 <elliott> start logreading
00:30:42 <elliott> it's fun + educational
00:30:44 <elliott> unless idiots were talking
00:31:00 <NihilistDandy> -unless
00:31:00 <elliott> speaking of which, Gregor really needs to add ignores to the codu log formatter
00:31:03 <NihilistDandy> Oh, snap
00:31:33 <elliott> 08:00:42: <cheater_> ais: nowadays people need to commute, it's a requirement of our way of life. it takes a special dedication for someone not to commute at all.
00:31:35 <elliott> cheater lives in a world consisting only of himself
00:31:40 <elliott> hmm, that's not funny, it's just accurate-looking :(
00:31:54 * elliott scrolls faster
00:32:37 <elliott> 08:06:03: <cheater_> OTOH the tube makes you ill and deaf, so i don't like it.
00:32:39 <elliott> damn that illifying tube gas
00:32:39 <NihilistDandy> Also, DeJaVu Sans Mono is the best monospaced font, period
00:32:44 <elliott> hahahaha
00:32:46 <elliott> yeah sure
00:32:50 <elliott> also you misspelled its name
00:32:54 <elliott> well miscapitalised.
00:33:04 <NihilistDandy> Did I? I never remember where the damn caps go
00:33:15 <NihilistDandy> Ah
00:33:18 <NihilistDandy> DejaVu
00:33:22 <NihilistDandy> There we go
00:33:35 <elliott> How many monospaced fonts have you used? :p
00:33:49 <NihilistDandy> A dozen regularly
00:33:53 <NihilistDandy> More experimentally
00:33:53 <cheater_> De Javu
00:36:09 <NihilistDandy> Inconsolata just doesn't have the Unicode coverage I want :D
00:37:01 <elliott> Inconsolata only renders nicely on OS X, which is odd since it wasn't created on OS X. I want to try Pragmata, but it costs a lot of money and I can't find it pirated anywhere.
00:37:09 <elliott> But I'm using DejaVu because it's the default. :p
00:37:19 <NihilistDandy> I have it
00:37:25 <NihilistDandy> Pragmata, that is
00:37:25 <elliott> (Anyway how much Unicode does your code have?)
00:37:25 <monqy> haha fonts that cost money
00:37:40 <elliott> NihilistDandy: Huh, where'd you get it? Don't tell me you paid for it. :p
00:37:47 <NihilistDandy> elliott: Hell no. I know a place
00:37:59 <NihilistDandy> elliott: I use Haskell fontlock in Emacs, and some of the characters are in obscure spaces
00:38:11 <elliott> Haskell fontlock =/= Haskell unicodeifying stuff
00:38:24 <NihilistDandy> No, but it displays stuff in pretty unicode ways
00:38:27 <elliott> NihilistDandy: A place just for fonts? That must be like the driest pirate cove in the universe.
00:38:32 <elliott> No
00:38:41 <elliott> It does not
00:38:41 <elliott> That is a separate thing
00:38:41 <elliott> haskell-mode does nothing of the sort
00:38:44 <NihilistDandy> elliott: It's actually for music. The fonts are just coincidental
00:38:55 <NihilistDandy> Hipsters like fonts, I guess
00:39:12 <elliott> NihilistDandy: Amazing. (I don't suppose it's one of the "famous" places.)
00:39:19 <NihilistDandy> Kinda famous, I guess
00:39:26 <NihilistDandy> I can dropbox you the font if you want
00:40:02 <elliott> That would be nice. (By famous I meant the few OiNK (did I get my hipster capitalisation right?) replacements.)
00:40:24 <NihilistDandy> Also, I'm not really sure how what the file haskell-font-lock.el is doing anything but what I said it does
00:40:31 <NihilistDandy> *other than
00:40:39 <elliott> 10:06:09: <fizzie> It's also quite common. Doesn't the Windows-bundled FreeCell also allow it? (With the old one having 32000 possible games, of which all but one are solvable, or something like that.)
00:40:44 <elliott> fizzie: There are like five unsolvable games, I think.
00:40:52 <elliott> Some of the negative numbers.
00:41:01 <elliott> NihilistDandy: Well, it is certainly not haskell-mode.
00:41:12 <elliott> There is an Emacs Unicode thing on the Haskell wiki.
00:41:22 <elliott> I don't know why it'd call itself haskell-font-lock.
00:41:35 <NihilistDandy> elliott: You can read it yourself. It's bundled with haskell-mode
00:42:06 <elliott> Hmm, it is?
00:42:10 <NihilistDandy> Yup
00:42:25 <NihilistDandy> You have to turn it on or hook it, but it's there
00:43:08 <NihilistDandy> Oh, actually I guess I just setq'd
00:43:08 <elliott> Oh, seems so.
00:43:11 <elliott> NihilistDandy: Well, it is a bad idea anyway.
00:43:16 <NihilistDandy> (setq haskell-font-lock-symbols t)
00:43:17 <elliott> NihilistDandy: It breaks indentation.
00:43:17 <NihilistDandy> Why?
00:43:22 <elliott> And alignment.
00:43:27 <NihilistDandy> Not noticeably, except in very few cases
00:43:31 <elliott> Doesn't matter
00:43:36 <elliott> It's a deal breaker
00:43:40 <elliott> Also using Unicode is a total hack for this.
00:43:53 <elliott> What you really want is some sort of realtime LaTeX-esque code rendering.
00:43:57 <NihilistDandy> Well, if you wanna do it better, I'm sure they'd love the effort
00:43:59 <NihilistDandy> :D
00:44:05 <elliott> But eh; this hack isn't even enough to fix the <*> operators.
00:44:21 <elliott> NihilistDandy: IF U CRITICISE FILM......... THEN WHY DONT U MAKE A BETTER FILM????/// CHECKMATE EBERT
00:44:25 <NihilistDandy> lol
00:44:42 <NihilistDandy> I didn't say you shouldn't criticize
00:44:46 <NihilistDandy> You just seem passionate about it :D
00:45:00 <elliott> I'm not passionate about it :P
00:45:08 <elliott> I'm just relatively certain it's a bad idea
00:45:21 <elliott> I could be more apathetic, if you'd like?
00:45:29 <NihilistDandy> And I'm relatively certain that if you're not braindead it is a non-issue :D
00:45:41 <NihilistDandy> I've had zero indentation issues
00:45:53 <NihilistDandy> :P
00:45:53 <elliott> It has demonstrable flaws, I'm allowed to point them out :p
00:48:01 <elliott> Heh, Pragmata is only legible at fourteen pt
00:48:12 <elliott> I feel like I'm blind
00:51:08 <oerjan> <elliott> I could be more apathetic, if you'd like? <-- so you say you could care less?
00:52:12 <CakeProphet> I could care in one of several directions.
00:52:30 -!- FireFly has quit (Quit: swatted to death).
00:52:40 <elliott> oerjan: :D
00:52:49 <monqy> i only care in spirals
00:53:06 <NihilistDandy> The Mandelbrot Sigh
00:53:59 <monqy> im too subhuman to care in fractals. spiral sigh.
00:58:54 <oerjan> to care in fractals is simple. just care in fractals, then care in fractals.
00:59:20 <NihilistDandy> You forgot the most important step
00:59:22 <Lymee> I think that's an infinite loop.
00:59:39 <Lymee> You need to say "just care in fractals, while caring in fractals at the same time"
00:59:47 <oerjan> sorry, s/then/and/
01:00:11 <oerjan> NihilistDandy: what step
01:00:27 <NihilistDandy> Care in fractals, of course
01:00:53 <NihilistDandy> let care = care in fractals
01:01:45 <Lymee> > takeWhile (>4) [1,2,3]
01:01:46 <lambdabot> []
01:01:48 <NihilistDandy> Anyway, off to work.
01:02:48 -!- NihilistDandy has quit (Quit: Workin').
01:04:48 -!- elliott has quit (Remote host closed the connection).
01:05:09 -!- elliott has joined.
01:05:16 <elliott> rip bats
01:06:57 <oerjan> that's animal abuse!
01:07:03 <oerjan> also, you might catch rabies
01:12:00 <elliott> :{
01:18:40 <CakeProphet> > let x = let y = y in x in 5
01:18:40 <lambdabot> 5
01:19:14 <oerjan> fancy
01:20:04 <CakeProphet> :t let y = y in y
01:20:05 <lambdabot> forall t. t
01:22:21 <CakeProphet> imagine if Haskell had only runtime errors and lazy evaluation
01:22:39 <CakeProphet> let y = ha ha ha ha ha ha ha in 4
01:22:52 <oerjan> what no scoping?
01:23:18 <CakeProphet> yes but the scoping errors only arise when the code executes
01:24:08 <CakeProphet> as it does in Python and Perl without strict.
01:24:54 <CakeProphet> though I guess syntax errors couldn't be runtime errors...
01:25:08 <elliott> sure they could :D
01:25:29 <CakeProphet> this would lead to some ambiguous parsing..
01:25:37 <CakeProphet> because EVERYTHING would have to parse correctly.
01:25:41 <CakeProphet> to be run
01:25:46 <CakeProphet> and then give a syntax error.
01:26:06 -!- itidus20 has quit (Ping timeout: 258 seconds).
01:26:08 <CakeProphet> unless you include parsing as part of "runtime"...
01:26:10 <oerjan> elliott: the problem is how late to detect them i guess. if you have a function definition it needs to be parsed before you can use it.
01:26:34 <oerjan> at least up to the point of finding out where it _ends_
01:26:45 <elliott> oerjan: sure but you can delay finding the values it _references_
01:26:52 <CakeProphet> yeah you just need to be able to discern the boundaries of things.
01:26:56 <elliott> <CakeProphet> unless you include parsing as part of "runtime"...
01:26:57 <elliott> yep
01:27:00 <oerjan> of course lisp makes this easy with the parens
01:27:08 <elliott> nope
01:27:12 <oerjan> and in haskell, layout can help
01:27:13 <elliott> you can modify the readtable
01:27:17 <oerjan> oh hm
01:27:39 <elliott> in some lisps, at least.
01:27:48 <oerjan> still, the readtable isn't modified until after the command which modifies it, i presume.
01:29:04 <oerjan> of course in haskell the insensitivity to declaration order makes it harder again...
01:31:20 <elliott> :)
01:32:38 <Sgeo> A copy of Canada's ruleset from 2008/4/28 has been recovered
01:33:02 <pikhq> Which Canada?
01:33:15 <Sgeo> The nomic
01:33:25 <Sgeo> ^^(still ambiguous, kind of)
01:33:47 <elliott> "I'm pretty sure you aren't allowed to have a T rating with that many stabbed children."
01:33:48 <pikhq> Which nomic. :)
01:33:49 <Sgeo> The one whose players would call it a "nomic"
01:33:51 <elliott> Sgeo: How amazing
01:33:53 <pikhq> Which nomic. :)
01:33:58 <elliott> Which nomic. :)
01:33:59 <elliott> Which nomic. :)
01:33:59 <elliott> Which nomic. :)
01:34:11 <elliott> But there are two nomics called Canada Sgeo it's true
01:34:21 <elliott> One lasted about ten messages.
01:34:33 <Sgeo> o.O
01:35:12 <elliott> "I'm pretty sure you aren't allowed to have a T rating with that many stabbed children."
01:35:13 <elliott> Wait
01:35:15 <elliott> I already quoted that >_<
01:51:40 <zzo38> Do you ever argue about relativity when playing D&D game?
01:52:00 <oerjan> relatively rarely.
01:52:48 <pikhq> Not much relativity.
01:52:55 <pikhq> Classical mechanics, fairly often.
01:53:20 <pikhq> Though the peasant railgun has elicited discussion of relativity.
01:58:28 <zzo38> alias ls 'echo ls: .: Permission denied'
02:06:52 <zzo38> I was arguing about relativity having to do with "Time Hop" power.
02:10:58 <elliott> woo, this is broken
02:15:55 <pikhq> zzo38: Oh dear, what happened.
02:16:29 <elliott> IamA The New Old Spices Man Fabio AMA (Internet keywords Romance, Fabio, Old Spice, Italian Supermodel, Italian, Motorcycle) (self.IAmA)
02:16:30 <elliott> internet keywords
02:17:38 <monqy> italiam supermodel motorcycle romance eh
02:17:49 <monqy> thanks internet keywords
02:18:02 <monqy> i could never have done it
02:18:02 <elliott> "Did anyone read The Silmarillion? That book explains everything. The entire Lord of the Rings is actually just the epilogue to incredibly epic saga that is The Silmarillion."
02:18:04 <monqy> without you
02:18:07 <elliott> isn't The Silmarillion like in encyclopedia form
02:18:10 <elliott> driest saga ever
02:18:57 <elliott> probably oerjan knows because i think he read all of the tolkein shit
02:19:02 <elliott> maybe
02:20:30 <oerjan> nah, i only read it until about the part where they created the sun and moon, i think
02:21:06 <elliott> i, too, hate the sun and the moon
02:21:21 <elliott> "SO the one ring is saurons horcrux? ya?"
02:21:22 <oerjan> then you, melkor and sauron have something in common.
02:21:36 <elliott> oerjan: i haven't read the bible, explain
02:21:37 <elliott> </oklopol>
02:21:45 <oerjan> :P
02:22:37 <oerjan> elliott: melkor/morgoth is the main evil guy, he destroyed the light sources they had previously on two occasions
02:22:53 <elliott> oh is that the satan guy
02:22:56 <elliott> also lol, moon's light source
02:23:00 <oerjan> more or less.
02:23:23 <elliott> "If Tom Bombadil wore the ring it would be as if Melkor returned. If i remember correctly, Bombadil is the most powerful character in the trilogy, similar or exactly like the gods created by illumitar. Therefore he has the most to lose if he was to wear the One Ring, because he had the such immense power that was corrupted for evil"
02:23:23 <elliott> "Tom Bombadil did wear the ring. It had absolutely no effect on him."
02:23:33 <oerjan> although after he is exiled from the world entirely, sauron takes over.
02:23:48 <elliott> where's he exiled to
02:23:51 <elliott> azkaban?
02:23:59 <elliott> i can't tell my religions apart
02:24:02 <oerjan> nah i think it was sort of outer space
02:26:21 <elliott> oerjan: so i take it tom bombadil's a pretty minor character
02:26:21 <oerjan> i think morgoth may have attacked the sun and moon at one point too, but failed in destroying them.
02:26:27 <elliott> i'm reading all about how he's like the most powerful thing in the universe
02:26:29 <elliott> and nature itself
02:26:32 <elliott> and im imagining this bit part
02:26:59 <monqy> how can the most powerful thing in the universe have the name tom
02:27:00 <oerjan> elliott: well the thing about him is that he is the only character in LoTR who is entirely unaffected by the ring, so it's easy to start speculating...
02:27:01 <monqy> how does that work
02:27:07 <elliott> oerjan: right :D
02:27:12 <elliott> oerjan: but he is minor yes
02:27:22 <oerjan> yes, he only show up briefly
02:27:25 <oerjan> *shos
02:27:28 <oerjan> *shows
02:28:18 -!- cheater_ has quit (Ping timeout: 255 seconds).
02:28:58 <oerjan> elliott: i have this weird vague idea that maybe morgoth's attack was how the moon got phases, or something like that.
02:29:22 <oerjan> this was around the point i stopped reading.
02:29:28 <elliott> lol
02:37:25 <Sgeo> Maybe I should read LOTR
02:37:38 <Sgeo> Got bored last time I started. But that was probably over a decade ago
02:38:08 <pikhq> Sgeo: Perhaps not.
02:38:13 <pikhq> LotR is not well-written.
02:38:31 <pikhq> In fact, it's fairly poorly written.
02:38:39 <pikhq> Brilliant setting, decent narrative, poor writing.
02:41:38 -!- cheater_ has joined.
02:43:58 -!- itidus20 has joined.
02:55:39 <coppro> yeah
03:02:05 <Sgeo> elliott, did you ever finish Dot Action 2?
03:02:23 <elliott> Sgeo: I don't think so :P
03:02:28 <elliott> But I tried all the levels at least
03:02:33 <elliott> The bonus ones were impossible
03:02:38 <elliott> (As in difficult)
03:02:56 <Sgeo> I remember one of the bonus ones being easy
03:05:53 <elliott> "First of all, I like Haskell a lot. I’m the Thompson in “Thompson-Wheeler Logo.” That cute shape that cleverly combines the lambda and monad bind shapes? My idea. The irony is not lost on me. That Haskell logo of mine is used all over the world, and yet I’m barely a mediocre Haskell programmer."
03:05:55 <elliott> UR SO FAMOUS
03:06:17 <zzo38> The thing with Time Hop power, is, I was trying to remove a device someone was wearing. I said they would still be wearing the device when it reappeared. The DM and other player thought not. However, I still knew a way to remove the device regardless, by putting a rock in the way.
03:06:44 <elliott> "Perhaps you formalists know handwaving over the details as the “Axiom of Choice,” no? I hearby invoke it."
03:06:48 <elliott> oh my god you're a shithead i'm not reading this post
03:08:08 <elliott> this is honestly the worst written thing ever
03:08:19 <elliott> im going to use another haskell logo because of how annoying this guy is
03:08:37 <Sgeo> elliott, linky?
03:08:45 <elliott> Sgeo: http://willowbend.cx/2011/07/22/whats-wrong-with-learning-haskell/, bring your shithead filter
03:09:15 <elliott> this guy is really, REALLY annoying and bad at writing and also has no good point
03:09:25 <elliott> oh the post is over already
03:11:23 <monqy> Confessions of a Wannabe Capitalist
03:11:26 <monqy> what does this mean
03:11:35 <elliott> oh my god that is his subtitle what
03:11:52 <monqy> wow this post
03:11:56 <monqy> is so bad
03:11:58 <elliott> it is
03:12:03 <elliott> he really hates DAMN FORMALISTS
03:12:18 <Sgeo> So he's not good at math, and wants resources to help him learn Haskell
03:12:30 <elliott> basically he wants people to put big warnings on their blog
03:12:32 <elliott> IF UR DUM DONT READ
03:12:34 <elliott> READ LYAH INSTEAD
03:12:35 <Sgeo> Although he keeps using "axiom of choice" randomly, I don't see what's wro.. oh
03:12:45 <elliott> because irc isn't good enough or i guess because he just didn't bother joining irc
03:12:55 <elliott> Sgeo: he knows there are resources
03:12:59 <elliott> he just wants people to tell him what not to read
03:13:02 <elliott> without him doing anything
03:13:15 <elliott> NOTE: I KNOW NOTHING
03:23:49 <itidus20> "It worked when I was learning Ruby. Not here. This was a bad idea. I learned nothing and it made me feel bad. Yeah, poor me." -- same effect as lurking in a japanese chatroom to learn japanese
03:24:11 <elliott> ++
03:24:27 <elliott> well, assuming it was a japanese chatroom about japanese. :p
03:25:22 <itidus20> it wasn't
03:25:42 <itidus20> well it was a japan-themed english chatroom
03:28:54 <itidus20> elliott: i am actually learning a lot from this article
03:29:06 <monqy> :(
03:30:28 <itidus20> doesn't mean i back the guy up but the idea of using haskell to prove things is good to know
03:32:04 <elliott> itidus20: not a good idea (Haskell's type system is an inconsistent logic)
03:32:08 <elliott> and it also has no facilities for the purpose
03:32:11 <elliott> nobody does that beyond a toy :P
03:32:16 <elliott> see Coq, Agda for this idea fully fleshed out
03:32:18 <elliott> (and safely)
03:32:19 <zzo38> I think someone used Haskell to prove Haskell
03:32:21 <elliott> more Coq
03:32:29 <elliott> zzo38: Haskell is too powerful for that...
03:32:29 <itidus20> but i actually got a damned good resource for people like me
03:32:36 <elliott> (Gödel)
03:32:38 <coppro> zzo38: Impossible
03:33:18 <itidus20> one thing I encountered when learning about compilers is a mysterious misconception that I had carried.
03:33:24 <zzo38> I know about Godel, although I did read somewhere, someone used to prove Haskell or at least part of it.
03:33:43 <itidus20> I'm not sure if it's analagous to a fractional component left over after a division.
03:34:04 <itidus20> But, Suppose you have a tower of blocks on the ground.
03:34:16 <itidus20> They stand together.
03:34:35 <itidus20> And yet, there is no glue.
03:34:44 <monqy> what
03:35:51 <zzo38> Gravity???
03:36:35 <elliott> wat
03:36:52 <elliott> coppro: not impossible, it just means that Haskell's type system is inconsistent, which it is :-P
03:37:08 <elliott> you can prove it already, it just won't be a very good proof
03:37:27 <copumpkin> http://www.eleves.ens.fr/home/amarilli/falso/
03:37:40 <monqy> mmmm falso
03:37:56 <elliott> http://www.eleves.ens.fr/home/amarilli/falso/axioms.png nice coq screenshot
03:38:46 <zzo38> Maybe the proof is its own counterexample
03:42:11 <coppro> elliott: Well, it depends on the semantics you assign to Haskell - if you use its type system, then yes
03:42:37 <elliott> coppro: the topic was proving things curry-howard-wise.
03:42:51 <elliott> so that's the only interpretation, proving Haskell's consistency with the proposition as a type and the proof as a value
03:43:39 <itidus20> one thing the layfolk like me tend to do is underestimate the spectrum of formally provable things
03:44:29 <itidus20> hmm
03:44:53 <itidus20> i was impressed by reading on wiki about the jordan curve proof i think it was called
03:45:16 <elliott> http://static.reddit.com/ads/takemymoney.jpeg no
03:51:20 <itidus20> So, looking at atoms or molecules vs looking at things the same relative size as us. I think this idea could become something cool in programming
03:51:49 <itidus20> (oh wait thats exactly what happens ;_; )
03:52:45 <itidus20> however
03:52:58 <itidus20> I have yet to see a high level game of life
03:54:09 <itidus20> When the level is so much higher than the baseline of live and dead cells that you couldn't recognize it anymore
04:00:17 <Sgeo> I am very bad at not being vaporware
04:02:06 <monqy> im vapourware irl
04:03:14 <oerjan> you both seem quite implemented to me
04:06:40 <Lymee> monqy, how perverted.
04:06:40 <Lymee> <:
04:06:42 <Lymee> :<
04:07:46 <elliott> what
04:08:01 <monqy> its perfectly normal for subhumans like me
04:08:15 <elliott> monqy: dont worry evolution will turn u into a human soon
04:08:18 <elliott> i know from pokemons
04:08:53 <elliott> god this mcmap code isso raciest to me
04:09:08 <Sgeo> Fuck politics
04:09:09 <Sgeo> http://www.politifact.com/truth-o-meter/statements/2011/apr/29/barack-obama/obama-regrets-2006-vote-against-raising-debt-limit/
04:09:12 <elliott> i HATE raciests,, they make me sick,.;
04:09:17 <elliott> <Sgeo> Fuck politics
04:09:20 <elliott> then sgeo talked about politics
04:09:22 <elliott> pro
04:11:33 * Sgeo wonders if SLIME works with Emacs 23.1
04:17:15 -!- elliott has quit (Remote host closed the connection).
04:17:22 -!- elliott has joined.
04:38:43 <elliott> pojdoijerioenoinefoinefoineoinef
04:43:20 -!- azaq23 has joined.
04:52:25 -!- copumpkin has quit (Ping timeout: 250 seconds).
04:52:50 -!- copumpkin has joined.
05:14:48 <oerjan> that's not a very readable presentation, randall.
05:15:14 <elliott> wow that is the stupidest thing
05:15:19 <elliott> has he finally given up
05:15:30 <coppro> It's not readable, but pretty awesome
05:15:36 <elliott> how's it awesome
05:15:41 <elliott> "i took some data BUT NOW IT IS POLAR........"
05:15:59 <Lymee> @hoogle findIndex
05:15:59 <lambdabot> Data.ByteString findIndex :: (Word8 -> Bool) -> ByteString -> Maybe Int
05:15:59 <lambdabot> Data.List findIndex :: (a -> Bool) -> [a] -> Maybe Int
05:15:59 <lambdabot> Data.Map findIndex :: Ord k => k -> Map k a -> Int
05:17:34 -!- elliott has quit (Remote host closed the connection).
05:17:37 -!- elliott_ has joined.
05:17:59 -!- TeruFSX has quit (Ping timeout: 250 seconds).
05:18:36 <monqy> i went to wiktionary a few times and now chromium won't stop autocompleting to wiktionary i want it to autocomplete to wikipedia so i can hit tab to make it search wikipedia this is the dumbest thing help
05:18:51 <Lymee> @pl \z -> (magnitude z) > 2
05:18:51 <lambdabot> (> 2) . magnitude
05:19:00 <elliott_> monqy: ok
05:19:00 <coppro> monqy: add a keyword for wikipedia
05:19:07 <elliott_> coppro: gross
05:19:13 <coppro> elliott_: no u
05:19:14 <elliott_> monqy: delete from history?
05:19:16 <monqy> how do i do that i am not good at this
05:19:23 <monqy> the keyword thing
05:19:24 <elliott_> erase,,,, the LIE
05:19:25 <monqy> unless keyword is bad
05:19:31 <elliott_> i dont even think chrome has those
05:19:39 <monqy> also how do i erase the lie
05:19:44 <monqy> oh there's a button
05:19:45 <monqy> thanks
05:19:47 <elliott_> monqy: chrome:history -> edit items
05:19:52 <monqy> yeah i hit it
05:19:59 <elliott_> then purge,,,
05:20:09 <coppro> I forget exactly how you do it in chrome
05:20:51 <elliott_> seems that http://www.google.com/support/chrome/bin/answer.py?answer=95653 is the only thing
05:20:52 <elliott_> but gross
05:20:53 <monqy> if i hit clear all browsing data will it clear all the wiktionary results but not the rest of my precious history which isn't lies
05:21:04 <coppro> monqy: yes
05:21:08 <coppro> monqy: obviously
05:21:09 <coppro> can't you read
05:21:42 <monqy> oh no it's not doing what i want it to do
05:21:51 <elliott_> monqy: you could just use the search history
05:22:08 <monqy> what's that how do i do that
05:22:12 <monqy> oh you mean that thing
05:22:17 <monqy> yeah I tried
05:22:31 <monqy> that's what i was talking about when i hit clear all browsing data i guess it actually meant all browsing data though
05:22:36 <monqy> and I can't find a select all
05:22:51 <elliott_> oh well
05:22:53 -!- MDude has quit (Read error: Operation timed out).
05:22:55 <elliott_> now u have less baggage
05:22:56 <elliott_> its zen
05:23:12 <elliott_> enjoy zen,
05:23:31 <Sgeo> You can delete search engnes
05:23:39 <monqy> I did that ages ago
05:23:45 <monqy> it still autocompleted to it
05:23:48 * oerjan deletes google MWAHAHAHAHA
05:24:08 * oerjan also deletes bing, to keep a sort of good/evil balance
05:24:10 <Sgeo> Right click address bar, edit search engines, removing, doesn't help?
05:24:10 <elliott_> monqy: purgaernces →manage searchkjnl; engines ---\→ delet wiktiaonry
05:24:18 <elliott_> Sgeo: poop u i do better
05:24:45 <oerjan> elliott_: you could hurt someone with those typos
05:24:53 <monqy> →→→
05:24:53 <elliott_> oerjan: yeah,,,like YUOU, DIE FUCKK
05:25:13 -!- derrik has joined.
05:25:13 <elliott_> <oeran> hurt inside ,_
05:25:17 <Sgeo> elliott_, did you sleep anytime within the past 14 days?
05:25:22 <elliott_> ive never a slep
05:25:38 <monqy> sometimes i a slep......like every night.....
05:25:56 <Sgeo> Got it. So, we're conversing with the sleep-deprived ghost of elliott_
05:26:02 <monqy> except on nights i dont a slep
05:26:08 <Sgeo> slep-deprived
05:26:27 <elliott_> <oerjan> feels bad, imnever a god person, probably offended elliott_ (best guy), criticise typelexia............................................ but remoserful + planning to become better
05:26:30 <elliott_> now our hero.........
05:26:49 <oerjan> *bizarro_oerjan
05:26:57 <monqy> 👍
05:27:19 <elliott_> oerjan: in an alternate universe............................................................................ you are a good person
05:27:45 <monqy> bizarro universe: a good place????
05:28:13 <oerjan> the BEST place. everyone got to kill people, fun!
05:32:26 -!- pikhq_ has joined.
05:35:43 -!- pikhq has quit (Ping timeout: 260 seconds).
05:42:33 <CakeProphet> oerjan: this reminds me of the Radiohead song Fitter, Happier
05:43:25 <elliott_> oerjan: have you ever read the gentle introduction
05:43:32 <elliott_> i kind of want to just so i can say it was easy
05:43:46 <CakeProphet> to... Haskell?
05:43:50 <monqy> i kind of want to just so i can say it was gentle
05:43:53 <oerjan> i cannot recall
05:44:11 <monqy> to category theory is it right
05:44:26 <oerjan> i assumed haskell...
05:44:30 <monqy> I could be confusing it with something else gentle though
05:44:35 <monqy> oh it could be haskell
05:44:44 <monqy> i am bad at gentle things
05:44:47 <monqy> :'(
05:45:21 <monqy> so is gentle introduction supposed not to be gentle
05:45:34 -!- myndzi\ has joined.
05:45:36 <elliott_> its mlgentle
05:45:45 <monqy> help whjat does thsi mean help
05:45:50 <Sgeo> SML or OCaml or what?
05:45:54 <elliott_> Our purpose in writing this tutorial is not to teach programming, nor even to teach functional programming. Rather, it is intended to serve as a supplement to the Haskell Report [4], which is otherwise a rather dense technical exposition. Our goal is to provide a gentle introduction to Haskell for someone who has experience with at least one other language, preferably a functional language (even if only an "almost-functional" language such as ML or Sc
05:45:55 <elliott_> heme). If the reader wishes to learn more about the functional programming style, we highly recommend Bird's text Introduction to Functional Programming [1] or Davie's An Introduction to Functional Programming Systems Using Haskell [2]. For a useful survey of functional programming languages and techniques, including some of the language design principles used in Haskell, see [3].
05:46:28 <Sgeo> Oh, you weren't saying that the title was "mlgentle"
05:47:03 <monqy> i dunno this looks pretty gentle
05:47:04 <Sgeo> <elliott_> [stuff]
05:47:14 <elliott_> monqy: i gather it becomes rough very soon
05:47:45 <monqy> im afraid i already know haskell
05:47:49 <monqy> judging this may be difficult
05:47:58 <elliott_> it mentions hindley milner on page two, gseveral times
05:48:01 <elliott_> a+
05:48:05 <monqy> i do not have formal education education............
05:48:24 <elliott_> Similarly, we could define Int (fixed precision integers) and Integer by:
05:48:24 <elliott_> data Int = -65532 | ... | -1 | 0 | 1 | ... | 65532 -- more pseudo-code
05:48:24 <elliott_> data Integer = ... -2 | -1 | 0 | 1 | 2 ...
05:48:24 <elliott_> no
05:48:26 <elliott_> not valid tutorial
05:48:28 <elliott_> notvalid int
05:48:30 <elliott_> needsmor,e unumbers
05:48:48 <monqy> -- This is not valid
05:48:50 <monqy> -- Haskell code!
05:48:54 <monqy> good coments⇧
05:48:59 -!- myndzi has quit (Ping timeout: 264 seconds).
05:49:08 <elliott_> sections on page three
05:49:09 <elliott_> im lol
05:49:34 <Sgeo> monqy, never know when an idiot is reading and thinks "Oh, I need to copy/paste this code for this assignment" or something
05:49:55 <monqy> the joke is that they put the code in there at all
05:50:07 <elliott_> http://www.haskell.org/tutorial/fig1.gif
05:50:12 <Lymee> @pl \x -> color $ mandelbrot iters x
05:50:12 <lambdabot> color . mandelbrot iters
05:50:18 <monqy> i like this daiagarm
05:50:25 <monqy> it makes
05:50:26 <elliott_> Lymee: you should learn to do simple pls like that in your head...
05:50:27 <monqy> snese
05:50:30 <CakeProphet> doesn't the Haskell spec mention Int being defined in that way kind of?
05:50:30 <oerjan> @src []
05:50:30 <lambdabot> data [] a = [] | a : [a]
05:50:36 <oerjan> monqy: ^ :P
05:50:47 <Lymee> Eh.
05:50:47 <oerjan> even the haskell report does it
05:50:47 <Lymee> Wait.
05:50:56 <Lymee> x.y = (x).(y), doesn't it.
05:51:01 <elliott_> um what
05:51:06 <elliott_> that's not a helpful question
05:51:08 <oerjan> Lymee: what?
05:51:16 <elliott_> are yuou asking about its precedence
05:51:19 <elliott_> (\x -> f (g x)) -> (f . g); f=color, g=mandelbrot iters
05:51:24 <monqy> the joke is that the haskell report does bad things :(
05:51:24 <elliott_> that's the easy way to reduce the above function
05:51:26 <monqy> and is a bad person
05:51:34 <monqy> i am not inviting the haksell report tyo my
05:51:34 <monqy> party
05:51:42 <elliott_> can i come to party
05:51:56 <monqy> do you do bad things are you a bad peeron
05:52:04 <elliott_> no
05:52:06 <monqy> ok
05:52:34 <oerjan> elliott_ almost never kills anyone
05:52:40 <elliott_> do you want to hear a joke monqy
05:52:46 <monqy> i like good jokes
05:52:51 <monqy> bad jokes too
05:52:54 <elliott_> c can't do any kind of parametric polymorphism at all
05:52:56 <elliott_> hahahaha
05:52:56 <monqy> mediocre jokes die in hell
05:52:58 <monqy> hahahahaha
05:52:59 <elliott_> (without macro abuse)
05:53:06 <monqy> one time i abuxsed macros
05:53:13 <CakeProphet> so I'm thinking it would be interesting to have a list type of sorts that basically puts a wrapper around the element type so that you can put "tags" and "sections" into the list.
05:53:18 <monqy> and pretended i could do paramatrec pomylorphism in c
05:53:26 <monqy> good
05:53:26 <monqy> times
05:53:40 <elliott_> CakeProphet: so um
05:53:44 <elliott_> ListWrap t a = [t a]?
05:53:45 <zzo38> What is parametric polymorphism?
05:53:46 <elliott_> good
05:53:51 <CakeProphet> both sections and tags are given unique identifiers. sections apply to every element of the list from when they start and finish, and tags are given to individual datums.
05:53:54 <CakeProphet> elliott_: yes.
05:53:54 <elliott_> zzo38: any sort of generic types
05:53:59 <CakeProphet> except it's more like...
05:54:03 <elliott_> zzo38: in C, you must define a separate type for a list of each element type
05:54:08 <elliott_> also a tuple of each element type, etc. etc. etc.
05:54:19 <CakeProphet> ListWrap t a = [Wrapper t a]
05:54:19 <elliott_> this means that you can't write generic algorithms of pretty much any sort without ugly (void *) hacks.
05:54:38 <monqy> i did ugly (void *) hacks
05:54:57 <monqy> and swept them under the proverbial carpet with
05:54:57 <CakeProphet> anyways, the end result is that you can define higher-order functions that allow you to manipulate only elements under a specific section or tag.
05:54:58 <monqy> macro abuse
05:55:00 <zzo38> You can, however, use macros in many ways, to define and to call with sizeof and so on
05:55:15 <CakeProphet> WHICH, would be useful, for example, in writing combinators to compose rhythmic patterns in a song. :)
05:55:31 <elliott_> CakeProphet: so um
05:55:43 <elliott_> map (\(t,x) -> if t==goodT then f x else x)
05:55:47 <CakeProphet> elliott_: no
05:55:56 <elliott_> mapTag t f = map (\(g,x) -> if t == g then f x else x)
05:55:57 <elliott_> hard
05:56:10 <CakeProphet> because that does not allow the sections, or untagged elements.
05:56:33 <CakeProphet> yes, what I'm doing is an abstraction for something else. Good job.
05:56:39 <elliott_> why do you need another type
05:57:17 <CakeProphet> data Wrapper t a = Tagged t a | Section t | EndSection t | Untagged a
05:57:23 <zzo38> Maybe you can even use it for checking signed/unsigned, checking with macros, somehow. Would this work? ((~(x&1
05:57:31 <zzo38> Maybe you can even use it for checking signed/unsigned, checking with macros, somehow. Would this work? ((~(x&1))<0)
05:57:46 <CakeProphet> elliott_: if you can find an easier way I'm all ears.
05:58:07 <elliott_> CakeProphet: i dunno, what you're doing seems really ugly?? especially that Section stuff where the list has to be of a certain structure but you're not enforcing it in the types
05:58:10 <monqy> why do you need sections what do they do
05:58:18 <monqy> also
05:58:30 <monqy> Section/EndSection
05:58:31 <monqy> is
05:58:32 <monqy> really
05:58:32 <monqy> ugly
05:58:33 <elliott_> in C if you do "void f(int n, char data[n])" is data passed like n parameters or as a pointer
05:58:59 <CakeProphet> they mark the beginning and end of.... sections in the list. I suppose you could just tag every element in the section or something...
05:59:14 <monqy> better to have something like Section [Wrapper t a] or if you odn't want nested sections split the datatype up[
05:59:26 <monqy> marking beginning and end is hell
05:59:29 <CakeProphet> they could nest.
05:59:48 <CakeProphet> I think I'll just stick to the tag approach, which would reduce it to a tuple ([t],a)
05:59:53 <CakeProphet> to allow for multiple tags or none.
06:00:04 <monqy> ok
06:00:15 <CakeProphet> and then a "section" is just a tag across every element in a certain point of the list.
06:00:35 <monqy> ok
06:01:19 <CakeProphet> I might encounter a problem where I have a lot of simultaneous events occur at the same time.. since I'll be using a list to represent a rhythmic pattern.
06:01:35 <CakeProphet> and then they won't be simultaneous because list doesn't work that way...
06:01:39 <CakeProphet> or something of that nature.
06:01:58 <monqy> ok
06:02:09 <CakeProphet> bah, assholes. :P
06:02:32 <elliott_> sorry we'll never say anything bad about ideas again
06:02:36 <elliott_> especially not "ok"
06:03:03 <CakeProphet> it's that the criticism is vague and not helpful, in the case of ok.
06:03:18 <elliott_> ok was criticism?
06:03:20 <elliott_> fuck
06:03:47 <CakeProphet> nevermind.
06:04:21 <elliott_> ok keep reading into things
06:04:34 <CakeProphet> as a human, I will read subtexts, yes.
06:04:46 <monqy> will you hate me if i smile
06:04:46 <monqy> cuz
06:04:48 <monqy> im smilen
06:04:53 <CakeProphet> noep.
06:04:53 <elliott_> "ok": 9/eleven of words,
06:04:57 <elliott_> <elliott_> in C if you do "void f(int n, char data[n])" is data passed like n parameters or as a pointer
06:04:58 <elliott_> does anyone no,
06:05:00 <elliott_> does Vorpal no
06:05:15 <CakeProphet> elliott_: ....pointer
06:05:18 <monqy> isw that even legal synraxt
06:05:21 <Vorpal> elliott_, I don't "no" but maybe I "know"
06:05:36 <Vorpal> elliott_, and definitely pointer
06:05:40 <monqy> if its legal its pointer
06:05:42 <CakeProphet> what do you think this is, Perl? lol
06:05:47 <monqy> lol
06:05:50 <elliott_> CakeProphet: its already weird c99 shit
06:05:52 <Vorpal> elliott_, wait is n there even legal?
06:05:56 <elliott_> Vorpal: yes. c99 shit
06:06:09 <Vorpal> elliott_, okay then I have no clue how that is passed
06:06:10 <monqy> c99 what did you do
06:06:15 <Vorpal> elliott_, *probably* pointer
06:06:20 <elliott_> Vorpal: thanks that's not helpful :(
06:06:23 <Vorpal> elliott_, I don't use VLAs much
06:06:28 <Lymee> elliott_, go test it.
06:06:33 <elliott_> Lymee: how
06:06:39 <elliott_> i guess i could print out addrs but
06:06:40 <elliott_> fuck that shit
06:06:48 <Lymee> data[0]=1
06:06:52 <Vorpal> elliott_, examine the registers of course in an __asm__ __volatile__ at the start!
06:06:57 <CakeProphet> it would seem to me that the [n] is meaningless, because it couldn't enforce a size because C is stupid and doesn't keep track of array size along with the array.
06:06:59 <elliott_> Lymee: it could be COW.................
06:07:15 <elliott_> CakeProphet: obviously C knows array size of arrays
06:07:18 <elliott_> you can sizeof them
06:07:24 <Lymee> COW?
06:07:29 <Vorpal> elliott_, I think it is equivalent of f(int n, char *data)
06:07:32 <lifthrasiir> afaik CakeProphet is right, only char data[static n] has a meaning.
06:07:40 <CakeProphet> elliott_: that will return the size of the pointer, yes.
06:07:47 <elliott_> lifthrasiir: "static n"? like that literally?
06:07:47 <Vorpal> elliott_, if it is even valid
06:07:53 <elliott_> CakeProphet: we are talking about arrays, not pointers.
06:07:57 <Vorpal> elliott_, no, like "fixed value of n"
06:07:57 <elliott_> Lymee: coppy on write
06:08:03 <CakeProphet> ....we are talking about C, where they are the same thing.
06:08:04 <Lymee> Ah.
06:08:05 <elliott_> Vorpal: i asked lifthrasiir
06:08:07 <elliott_> CakeProphet: hahaha nope
06:08:07 <Vorpal> elliott_, I don't think VLA extends to function prototypes
06:08:12 <Vorpal> but I could be wrong
06:08:16 <elliott_> arrays are not the same thing as pointers and anyone who says so is lying
06:08:38 <lifthrasiir> umm, wait, [static <number>] is definitely allowed but [static n] is not sure
06:08:41 <Vorpal> elliott_, in function prototypes they tend to be. char *foo is passed the same as char foo[]
06:08:53 <elliott_> Vorpal: so you were wrong, it does not mean "fixed value of n"...
06:08:57 <elliott_> and that's not the point.
06:08:59 <elliott_> i was takling about sizeof.
06:09:11 <Vorpal> elliott_, what, you lost me
06:09:20 <elliott_> k
06:09:21 <Vorpal> <elliott_> <elliott_> in C if you do "void f(int n, char data[n])" is data passed like n parameters or as a pointer
06:09:27 <CakeProphet> I'm pretty sure the only difference is allocation. The actual value of an array is the pointer to the first element, always. sizeof will yield the size of that pointer.
06:09:29 <Vorpal> elliott_, I thought that was what we were talking about?
06:09:30 <zzo38> C99 probably allows thing like that, I think it is an unnecessary feature of C99 though, C99 has a few good features
06:09:40 <elliott_> CakeProphet: you are wrong.
06:09:46 <elliott_> sizeof(x)/sizeof(x[0]) will yield the length of an array.
06:09:53 <elliott_> also see http://www.lysator.liu.se/c/c-faq/c-2.html for more information.
06:09:55 <Vorpal> yeah
06:10:47 <monqy> c hurts
06:10:49 <monqy> my head
06:11:15 <zzo38> Yes, for purpose of sizeof, the array type is the entire array, but when just using a value by itself it is a pointer instead.
06:11:26 <Vorpal> <elliott_> in C if you do "void f(int n, char data[n])" is data passed like n parameters or as a pointer <-- I think http://www.lysator.liu.se/c/c-faq/c-2.html 2.4 applies here
06:11:43 <elliott_> i don't even know that that page is updated for c99
06:11:45 <elliott_> i googled it up
06:11:47 <CakeProphet> elliott_: ah okay, I see.
06:11:58 <elliott_> its even the old version of the c-faq
06:12:02 <Vorpal> hm
06:12:08 <elliott_> This article is Copyright 1988, 1990-1995 by Steve Summit. It may be freely redistributed so long as the author's name, and this notice, are retained.
06:12:09 <CakeProphet> that's a pretty common misconception then.
06:12:23 <CakeProphet> at least in online literature about C.
06:12:29 <elliott_> CakeProphet: yes. mostly among people who don't know/never use C (and then sometimes try to teach it)
06:12:38 <elliott_> or the people who use C without actually knowing a single thing about C, which is most people who use C
06:12:39 <lifthrasiir> hmm, seems gcc ignores "static" completely in this case?
06:12:58 <elliott_> basically I want the array passed as values here, though. :/
06:12:59 <zzo38> Maybe LLVM is a bit better designed, although, it would still work far better with having macros preprocessor and that stuff.
06:13:16 <elliott_> i.e. I wish "size_t size, char head[size]" passed the same as `size` parameters.
06:13:31 <Vorpal> lifthrasiir, what would "static" there even do
06:14:17 <monqy> passed by values?
06:14:25 <CakeProphet> elliott_: so does the pointer decay occur when the array is passed to a function? as this would make the utility of being able to use sizeof to get the length of an array very small.
06:14:27 <zzo38> I think a structure can be passed as value in C
06:14:29 <elliott_> monqy: yes
06:14:30 <lifthrasiir> Vorpal, void f(int n, char data[static 256]) (for example) requires the caller to supply an actual char array with at least 256 elements to data
06:14:33 <monqy> would memcpy work or is that dumb and for dumb people
06:14:34 <elliott_> CakeProphet: yes. but it is not a small utility at all.
06:14:42 <elliott_> it is a widely used idiom
06:14:44 <Vorpal> lifthrasiir, and plain data[256] means?
06:14:46 <elliott_> elliott@katia:~/Code/mcmap$ grep -r NELEMS .
06:14:46 <elliott_> ./cmd.c:for (int i = 0; i < NELEMS(commands); i++)
06:14:46 <elliott_> ./world.c:for (int i = 0; i < NELEMS(region->chunks); i++)
06:14:46 <elliott_> ./world.c:for (int j = 0; j < NELEMS(region->chunks[i]); j++)
06:14:46 <elliott_> ./world.c:for (int i = 0; i < NELEMS(region->chunks); i++)
06:14:47 <elliott_> ./world.c:for (int j = 0; j < NELEMS(region->chunks[i]); j++)
06:14:48 <lifthrasiir> nothing.
06:14:49 <elliott_> ./map.c:for (int i = 0; i < NELEMS(region->dirty_chunk); i++)
06:14:51 <elliott_> ./common.h:#define NELEMS(array) (sizeof(array) / sizeof((array)[0]))
06:14:53 <Vorpal> lifthrasiir, huh
06:14:55 <lifthrasiir> that's just like data[] or *data.
06:14:56 <elliott_> and that's a small-ish codebase.
06:15:00 <lifthrasiir> (afaik)
06:15:10 <elliott_> CakeProphet: you can use it for statically-sized global arrays, or statically-sized arrays in structures.
06:15:16 <Vorpal> lifthrasiir, so it is basically like causing a warning or error if not large enough?
06:15:17 <elliott_> which is many arrays. perhaps even most.
06:15:19 <CakeProphet> elliott_: so then this code doesn't receive array as a parameter?
06:15:22 <CakeProphet> ah.
06:15:30 <elliott_> CakeProphet: of course you can pass a structure with an array.
06:15:34 <CakeProphet> right.
06:15:34 <elliott_> that works fine and doesn't decay.
06:15:38 <elliott_> (rhymes)
06:15:39 <lifthrasiir> Vorpal, in principle, yes, but gcc seems ignoring this even in the C99 mode.
06:15:45 <monqy> c :(
06:15:48 <Vorpal> lifthrasiir, heh
06:16:11 * CakeProphet wonders what else he does not know about C. probably many things.
06:16:24 <lifthrasiir> i found at least one example of this declaration from Google code search: http://google.com/codesearch#1IKf2ZWr9OM/deps/third_party/xz/src/liblzma/check/sha256.c&l=83
06:17:06 <lifthrasiir> maybe that's the intended use of that kind of declarations.
06:17:23 <CakeProphet> elliott_: so when I write code outside of functions to deal with arrays I should really be declaring with type type[] instead of type*
06:17:38 <CakeProphet> er, well, using static variables, not outside of functions. :P
06:17:42 <elliott_> um why
06:17:47 <elliott_> that makes no difference
06:17:52 <elliott_> and is more misleading really
06:17:52 <CakeProphet> because they are different, according to this thing you linked me.
06:18:08 <elliott_> well you probably mean to use a pointer.
06:19:29 <CakeProphet> but wouldn't assigning the array to a pointer destroy the sizeof property?
06:20:01 <lifthrasiir> yes, that IS a problem.
06:20:40 <elliott_> CakeProphet: of course it does.
06:21:12 <CakeProphet> so what I'm saying is that if I want to use that property then I should declare as type[] instead...
06:21:41 * CakeProphet is going to troll some of his C programmer friends now....
06:21:52 <zzo38> I have used interpreted C codes in a prepreprocessor to do some things related to types, and combined with macros and include files, to make initialization for different structures, copied, without duplication, indicated as a type, and so on. Maybe a bit like using "<types>" style codes in C++ but different and with less stupid syntax
06:22:33 <CakeProphet> <types> as in templates or...?
06:22:35 <zzo38> CakeProphet: Are you sure you understand it enough?
06:22:54 <CakeProphet> zzo38: I understand the difference between arrays and pointers now, which means I can troll that specifically.
06:23:27 <zzo38> CakeProphet: Yes, I think < > is used for templates syntax in C++, which is dumb since it is also less than/greater than
06:24:30 <zzo38> OK, now you understand difference. There is many difference, but "I should really be declaring with type type[] instead of type*" I don'r know.
06:25:16 <CakeProphet> type[], not type type[]... the first type is part of my sentence or whatever. :P
06:25:45 <zzo38> Yes I understood that much.
06:25:56 <CakeProphet> I didn't mean that I should declare like that ALL the time, just in those situations where the sizeof an array is valuable.
06:26:01 <CakeProphet> is there still something wrong with that?
06:26:05 <zzo38> But, the C syntax for comments is also a bit dumb since /* even with no comments is not a syntax error, while // is a syntax error otherwise so it would be better idea using it as comments.
06:26:15 <oerjan> if your declaration is allocating room for the array, you should use [] obviously?
06:26:40 <CakeProphet> ..yes, I would say this is preferred.
06:26:48 <zzo38> Yes using [ ] in declaration declares its space is the point.
06:26:53 <CakeProphet> zzo38: you would not like Perl. :)
06:27:02 <oerjan> because * only allocates the pointer.
06:27:29 <zzo38> So don't expect to assign directly to a [ ] type because that is not how array work in C.
06:27:44 <CakeProphet> ah okay, right.
06:27:59 <CakeProphet> I was thinking of a malloc, but that is already a pointer anyways...
06:28:59 <CakeProphet> so technically a dynamically allocated array is not a "real" C array.
06:29:06 <zzo38> Yes.
06:31:53 <zzo38> Declarations such as char *p; fine OK to me, it make sense. However, thing such as char *p=q+1; is stupid is make no sense wirh the space in that position.
06:32:46 <zzo38> (I omit the space in both cases however)
06:33:25 <CakeProphet> hmmm, okay so is a dynamically allocated array a pointer to an array or a pointer to the first element? second case, right?
06:34:06 <elliott_> Yes.
06:34:21 <elliott_> There are no arrays involved here; calling it "dynamically allocated memory" might answer some questions.
06:34:32 <CakeProphet> well, right.
06:34:55 <CakeProphet> but that becomes awkward to talk about. I think it still makes sense to talk about it as an array.
06:35:08 <CakeProphet> even though it's... not one in the way that C defines it.
06:36:25 <CakeProphet> "loop through the dynamically allocated memory" instead of "loop through the array". But yeah, I see that calling it that is good to highlight the difference for educational purposes.
06:38:16 <CakeProphet> hmmm, okay, so another consequence of this is that dynamically allocated 2-dimensional "arrays" have to be manually subscripted via arithmetic instead of using the [][] notation.
06:38:31 <elliott_> um
06:38:34 <elliott_> not if you do them as pointers to pointers
06:39:22 <CakeProphet> oh, right. Instead of one malloc you have 1 + ncolumns mallocs.
06:40:09 * Sgeo considers reading My Immortal
06:40:24 <Sgeo> I tried once before
06:40:36 <elliott_> did you like it legitimately
06:41:06 <CakeProphet> the only C programming I have done involved a MUD codebase. So I suppose I could afford to skip knowing this distinction and still get away with it.
06:41:23 <CakeProphet> for... several years, actually. :P
06:42:11 <Sgeo> elliott_, do you think my taste is that atrocious?
06:42:16 <elliott_> Sgeo: Yes.
06:42:25 <elliott_> list.c:45: error: incompatible types when assigning to type ‘struct <anonymous>’ from type ‘struct <anonymous>’
06:42:37 <CakeProphet> ....hahaha
06:43:15 <CakeProphet> also, C has anonymous structs?
06:44:14 <elliott_> struct { ... }
06:45:18 <CakeProphet> how are you assigning to type struct <anonymous>
06:45:30 <elliott_> list = ((struct { typeof((list).empty[0]) empty[0]; GenericList *generic_list; }){ .empty = {}, .generic_list = generic_list_tail((list).generic_list) });
06:45:31 <Deewiant> struct { int x; } s;
06:45:32 <Deewiant> s.x = 0;
06:45:33 <elliott_> any questions
06:45:50 <elliott_> seems that C doesn't unify anonymous structures with identical fields
06:45:51 <elliott_> sigh
06:45:51 <CakeProphet> oh that's.... interesting.
06:45:57 <elliott_> this makes this ten times harder than i expected :D
06:46:12 <elliott_> oh wait
06:46:14 <CakeProphet> you can't just de-anonymize it?
06:46:16 <elliott_> is (typeof foo){ ... } a valid struct literal
06:46:16 <elliott_> CakeProphet: no
06:46:57 <CakeProphet> elliott_: void pointers maybe?
06:47:17 <elliott_> no
06:47:58 <CakeProphet> woah, so you write .field = ...?
06:48:04 <CakeProphet> I have never seen this before, ever.
06:48:42 <elliott_> starting to wonder how much C you've used, tbh
06:48:45 <elliott_> this is C99
06:49:34 <CakeProphet> not as much as I thought, apparently.
06:50:28 <CakeProphet> so why can't you use named structs again?
06:50:33 <elliott_> macro shit
06:50:38 <CakeProphet> ah... yes.
06:51:15 <elliott_> haha wow that actually works hmm
06:51:30 <CakeProphet> (I mean, I don't really understand why that restricts you from naming the structs)
06:51:30 <zzo38> Correct, C doesn't unify structures. LLVM does, however.
06:51:39 <Deewiant> Not any more it doesn't.
06:51:39 <CakeProphet> but sure, I'll accept "macro shit" as a valid reason.
06:51:47 -!- derrik has quit (Quit: :().
06:52:24 <zzo38> (But fields of structures in LLVM cannot have names anyways)
06:53:19 <CakeProphet> structs are almost like heterogenous arrays. Is this a valid characterization?
06:53:57 <CakeProphet> the only thing that really breaks that idea is that structs can't be subscripted..
06:54:31 <CakeProphet> but in memory it's the same structure as an array, except with heterogenous types.
06:54:52 <elliott_> struct { int empty[0]; GenericList *generic_list; } list = ({ typeof((list).empty[0]) _list_cons_head_1 = (0); (typeof(list)){ .empty = {}, .generic_list = generic_list_cons(sizeof(_list_cons_head_1), (char *) &_list_cons_head_1, (({ typeof((list).empty[0]) _list_cons_head_0 = (9); (typeof(list)){ .empty = {}, .generic_list = generic_list_cons(sizeof(_list_cons_head_0), (char *) &_list_cons_head_0, (((typeof(list)){ .empty = {}, .generic_list = gener
06:54:52 <elliott_> ic_list_empty })).generic_list) }; })).generic_list) }; });
06:54:52 <elliott_> return (*((typeof((((typeof(list)){ .empty = {}, .generic_list = generic_list_tail((list).generic_list) })).empty[0]) *) generic_list_head((((typeof(list)){ .empty = {}, .generic_list = generic_list_tail((list).generic_list) })).generic_list)));
06:55:18 <CakeProphet> elliott_: what is wrong with you.
06:55:22 <elliott_> macro shit
06:55:54 <oerjan> he's shitting macros
06:55:54 <CakeProphet> int empty[0];????
06:56:06 <elliott_> CakeProphet: for typeof.
06:56:09 <elliott_> and sizeof.
06:56:09 <monqy> hi guys im back from being away did bad stuff happen
06:56:11 <elliott_> int is T
06:56:27 -!- olsner has joined.
06:56:51 <zzo38> Zero-element arrays can be very useful sometimes.
06:56:52 <CakeProphet> elliott_: you can't just say... typeof(1)?
06:57:16 <CakeProphet> elliott_: you can't just say... typeof((int)1)? :P
06:57:21 <elliott_> CakeProphet: int is T.
06:58:12 <CakeProphet> I don't really know what that means, then. You mean it's the type parameter in your macro shit?
06:58:15 <elliott_> yep
07:00:06 <CakeProphet> why not just write T then?
07:00:06 <zzo38> Maybe in LLVM, you could ensure different types having something like a last element of a structure of a type [0 x [1 x i8]], [0 x [2 x i8]], [0 x [3 x i8]], and so on, to make then unique if you wanted them different.
07:00:17 <elliott_> CakeProphet: thats totally not the cpp output.
07:00:20 <elliott_> nope.
07:00:36 <elliott_> <zzo38> Correct, C doesn't unify structures. LLVM does, however.
07:00:36 <elliott_> <Deewiant> Not any more it doesn't.
07:00:37 <elliott_> howso btw
07:00:42 <elliott_> gimme details about this thing i know nothing about
07:00:55 <Deewiant> Since I don't know, a week ago, when Chris's patch landed for LLVM 3.0
07:01:54 <CakeProphet> I'm just not entirely sure why you have to do all of this typeof expansion stuff when you could just substitute T where you need the type T...
07:02:15 <zzo38> What patch is this? I like the feature of LLVM unifying structures, it is a useful feature
07:02:45 <monqy> being generic is for losers
07:02:51 <elliott_> CakeProphet: because i dont know t
07:02:58 <elliott_> #define List(T) struct { T empty[0]; GenericList *generic_list; }
07:02:58 <elliott_> #define list_create(name) ((typeof(name)){ .empty = {}, .generic_list = generic_list_empty })
07:02:58 <elliott_> #define list_cons(head, tail) list_cons_(head, tail, __COUNTER__)
07:02:58 <elliott_> #define list_cons_(head, tail, id) list_cons__(head, tail, id)
07:02:58 <elliott_> #define list_cons__(head, tail, id) \
07:02:58 <elliott_> ({ \
07:03:00 <elliott_> typeof((list).empty[0]) _list_cons_head_##id = (head); \
07:03:01 <monqy> l o s e r
07:03:02 <elliott_> (typeof(list)){ \
07:03:04 <elliott_> .empty = {}, \
07:03:06 <elliott_> .generic_list = generic_list_cons(sizeof(_list_cons_head_##id), (char *) &_list_cons_head_##id, (tail).generic_list) \
07:03:09 <elliott_> }; \
07:03:13 <elliott_> })
07:03:15 <elliott_> #define list_head(list) (*((typeof((list).empty[0]) *) generic_list_head((list).generic_list)))
07:03:17 <elliott_> #define list_tail(list) ((typeof(list)){ .empty = {}, .generic_list = generic_list_tail((list).generic_list) })
07:03:20 <elliott_> feel free to make better and also make working
07:03:33 <Deewiant> Okay, so it was more than a week ago
07:03:35 <Deewiant> http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-Mon-20110704/123705.html
07:03:40 <monqy> that looks like the sort of stuff i wrote two years ago before i got sick of it
07:03:40 <CakeProphet> oh I see. You use the zero-width array to carry the type information beyond the macro body.
07:04:27 <elliott_> zzo38: caret to Deewiant
07:05:22 <elliott_> Deewiant: is there a discussion thread for that commit
07:05:34 <Deewiant> Maybe
07:05:34 <zzo38> Does that only apply to named types? Or to anonymous types too?
07:05:49 <elliott_> Deewiant: Thx
07:06:11 <Deewiant> elliott_: It's something that's been on his todo list for a long time now
07:06:46 <Deewiant> zzo38: Anonymous types are uniqued by their contents
07:07:10 <CakeProphet> elliott: void pointers. everywhere.
07:07:12 <zzo38> Deewiant: That makes sense, now.
07:07:29 <CakeProphet> elliott_: terrible casts, everywhere.
07:08:25 <zzo38> So, an anonymous structure with the same types of elements should be considered to be same types, otherwise not?
07:08:46 <CakeProphet> same types in the same order, I would think.
07:08:48 <Deewiant> Yes, otherwise the name is part of the identity
07:09:33 <zzo38> OK, it does make sense, now, then.
07:09:54 <zzo38> CakeProphet: Yes it is what I meant
07:09:58 <CakeProphet> elliott_: you could cast the anonymous structs to a named struct within each macro maybe?
07:10:12 <CakeProphet> using... magic unique naming skills?
07:10:28 <CakeProphet> #define macro(x, y, keysmash)
07:11:07 <CakeProphet> so everytime someone has to use your macros they must angrily smash alphanumeric characters into the last field to provide a unique name for the struct.
07:11:27 <monqy> :'(
07:12:18 <pikhq_> CakeProphet: The typical trick is just __LINE__.
07:13:34 <monqy> no hygenic macros and no way to generate unique names?
07:13:37 <oerjan> that won't work if you must do it more than once in the same line, no?
07:13:56 <CakeProphet> well, it wouldn't work if the cast was on a different line than the struct definition.
07:14:41 <monqy> are there any better preprocessors
07:14:50 <pikhq_> monqy: m4?
07:15:06 <CakeProphet> C? No. never. No one would ever write a C preprocessor.
07:15:34 <CakeProphet> template C.
07:16:08 <CakeProphet> you could write a macros that play waiting music as your code compiles.
07:16:41 <oerjan> eine kleine nachtmakro
07:17:21 <CakeProphet> I suppose you could also write macro compilers or something.
07:17:38 <CakeProphet> assuming it was basically like TH but for C, and without the strict typing.
07:17:45 <itidus20> #playsound
07:18:16 <itidus20> :o
07:19:34 <itidus20> you could have #playnotes ABCBCBA
07:20:00 <CakeProphet> and that would... play them all in equally spaced intervals?
07:20:12 <itidus20> or uhmm.. a compilation visualizer?
07:20:39 <CakeProphet> this would be pretty cool.
07:20:42 <itidus20> like a music visualizer
07:20:54 <itidus20> except maybe it could have the token stream fed into it
07:21:48 <CakeProphet> I was imagining more of like an animation of the code text compiling into intermediate representations and then machine code.
07:22:06 <zzo38> pikhq_: m4 is not for C.
07:22:55 <elliott_> it can work with C
07:23:02 <elliott_> and was defined for a C-like language
07:23:05 <CakeProphet> Perl is probably a pretty good C preprocessor.
07:23:12 <CakeProphet> :)
07:23:14 <zzo38> monqy: What about... Enhanced CWEB? It also includes a C interpreter, among other things. The C interpreter can send codes to the C compiler. And the program can even be printed out.
07:23:39 <zzo38> CakeProphet: I suppose you can do so, if you wanted to
07:23:41 <monqy> ooh
07:23:51 <itidus20> or you could do a 3d visualization as like a factory
07:24:40 <zzo38> I think m4 is not very good for C, though. But I maybe it will work if configured correctly for use with C.
07:24:42 * pikhq_ declares Bourne the best C preprocessor.
07:25:34 <CakeProphet> it's the only C preprocessor that allows you to compile C code.
07:25:46 <CakeProphet> .... (blatantly not true, shhhhh)
07:25:49 <pikhq_> Or any other code.
07:26:14 <itidus20> I am interested in data re-representations.. i don't know a better words
07:26:18 <itidus20> ^word
07:26:27 <itidus20> perhaps interpretations is a better word
07:26:38 <zzo38> Well, at least I prefer CWEB, for writing my C codes
07:26:44 <CakeProphet> sounds like converting one data structure to another, yes?
07:26:54 <zzo38> (Even if you hate it instead)
07:27:01 * CakeProphet knows all of the codes.
07:27:10 <itidus20> one example being converting music into visualizations.
07:27:42 <itidus20> its a niche area
07:28:21 <CakeProphet> itidus20: try running aplay on a pdf or /dev/urandom
07:28:24 -!- oerjan has quit (Quit: leaving).
07:28:30 * itidus20 opens up my personal wiki
07:28:46 <CakeProphet> itidus20: go write about it on your blag.
07:28:52 <itidus20> i have a winxp box. i've never had any form of *nix installed :-s
07:29:09 <itidus20> im that kind of person
07:29:30 * CakeProphet types "aplay /dev/urandom" and listens to delicious pseudo white noise
07:29:46 <itidus20> hmm.. i called the page bit field encoding
07:30:36 <zzo38> You can get a continuous tone by playing output of "yes" command, in Linux.
07:30:44 <pikhq_> itidus20: Wow, the only OS worse than *nix.
07:30:48 <pikhq_> (still in common use)
07:30:53 <CakeProphet> elliott_: what's the best way to seed random without using IO?
07:30:55 <monqy> yes is a good command
07:30:56 <CakeProphet> is there even such a way?
07:31:19 <pikhq_> zzo38: Wow, sure enough.
07:31:24 -!- elliott_ has quit (Ping timeout: 246 seconds).
07:31:31 <zzo38> The "yes" command can have many uses.
07:31:34 <itidus20> CakeProphet: what do you mean IO?
07:31:40 <itidus20> do you mean like in space invaders? :D
07:31:41 <pikhq_> aplay <(yes) actually does that.
07:31:47 <zzo38> pikhq_: Surely it is obvious?
07:31:54 <CakeProphet> er, no I was referring to
07:31:57 <CakeProphet> Haskell actually.
07:32:02 <pikhq_> zzo38: Well, yes, it's obvious how it would do that.
07:32:05 <itidus20> ahh ok IO monad
07:32:23 <pikhq_> zzo38: It's an oscillation between y and \n, which would, of course, produce a constant tone.
07:32:32 <CakeProphet> zzo38: it's a very high frequency sin tone right?
07:32:39 <pikhq_> Of very high frequency.
07:32:48 <CakeProphet> ooooh, I forgot about the \n
07:32:58 <CakeProphet> I wonder if it aliases.
07:33:00 <pikhq_> Half the sample rate.
07:33:07 <CakeProphet> ...ah.
07:33:31 <CakeProphet> so it is the nyquist frequency, interesting.
07:33:36 <pikhq_> aplay defaults to 8000 Hz sample rate, so it's a 4 kHz tone.
07:34:06 <zzo38> Now use a 5200 Hz sample rate........
07:34:38 <pikhq_> Which, of course, does a 2.6 kHz tone.
07:34:50 <itidus20> CakeProphet: this is a pic of the page in my private wiki: http://oi52.tinypic.com/wqsorr.jpg
07:34:53 <zzo38> Yes.
07:36:28 <zzo38> I once wrote a program in Linux that generates many kinds of telephone signals. Including DTMF, silver box, red box, blue box, dial tone, busy signal, reorder, SIT, etc.
07:37:16 <zzo38> Including both American and Commonwealth ringback tones! And red box for many countries.
07:38:26 <zzo38> If you live in North America, program your computer to play the Commonwealth ringback tone when someone calls you............
07:41:08 <CakeProphet> changing the string that yes outputs leads to fun things.
07:41:22 <CakeProphet> yes `echo -ne "\255"` gives you the max amplitude signal.
07:41:53 <CakeProphet> and then adding more characters adds more spectral qualities and lowers the frequency.
07:42:19 <pikhq_> yes `printf "\x255"` does so on POSIX systems.
07:42:24 -!- Taneb has joined.
07:42:29 <Taneb> Hello
07:42:36 <pikhq_> Erm, '\x255'
07:43:06 <CakeProphet> by default it's a triangle wave.
07:43:15 <CakeProphet> but I bet you could get a sine tone.
07:44:25 <CakeProphet> well, hmmm.. I think you might need floating point numbers for that.
07:44:55 <pikhq_> No.
07:45:39 <pikhq_> If you want a perfect sine tone, what you need is infinite-bit sampling.
07:45:53 <CakeProphet> that's obviously not what I mean though.
07:46:21 <pikhq_> And there will be no notable benefit to floating point over integer samples if both are bounded.
07:46:54 <CakeProphet> > map (toEnum.(+10).(*245).sin) [1..]
07:46:55 <lambdabot> No instance for (GHC.Float.Floating GHC.Types.Int)
07:46:55 <lambdabot> arising from a use of...
07:47:07 <CakeProphet> > map (toEnum.(+10).(*245).round.sin) [1..]
07:47:08 <lambdabot> [*Exception: Prelude.Enum.().toEnum: bad argument
07:47:29 <CakeProphet> ...lol
07:47:32 -!- zzo38 has quit (Remote host closed the connection).
07:47:37 <CakeProphet> I am trying to get the sequence of characters to generate a sine tone.
07:47:54 <CakeProphet> a sequence of characters, anyways.
07:48:11 <CakeProphet> > map (toEnum.(+10).(*245).round.sin) [1..] :: [Char]
07:48:13 <lambdabot> "\255\255\n*Exception: Prelude.chr: bad argument: (-235)
07:48:28 <CakeProphet> ah.
07:48:32 <CakeProphet> has to be unsigned.
07:49:49 <CakeProphet> > map (toEnum.abs.round.(+10).(*245).sin) [1..] :: [Char]
07:49:50 <lambdabot> "\216\233-\175\225:\171\252o{\235yq\253\169=\226\174/\234\215\b\197\212\SYN...
07:49:56 <CakeProphet> that's not going to be right though.
07:53:18 <CakeProphet> > map (toEnum.abs.round.(+10).(*245).sin.(/(25*pi))) [1..] :: [Char]
07:53:19 <lambdabot> "\r\DLE\DC3\SYN\SUB\GS #&),/259<?BEHKNQTWZ]`behknqtvy|\DEL\129\132\135\138\...
07:53:22 <Taneb> Well, Binary Variety Pack now has functional, imperative, and string rewriting.
07:54:13 <CakeProphet> also abs != convert signed to unsigned.
07:54:37 -!- GuestIceKovu has joined.
07:55:20 <Taneb> Now I need a fourth paradigm to add to BVP
07:55:34 <CakeProphet> you probably want aspect-oriented.
07:56:20 -!- Slereah has quit (Ping timeout: 240 seconds).
07:56:39 <Taneb> Okay
07:57:49 <CakeProphet> or modular, or template-based (aka macros), or unstructured, or logic-oriented
07:58:51 <Taneb> I might go for a cellular automaton
08:00:07 <CakeProphet> why settle for only one?
08:00:22 <CakeProphet> a cellular automaton of cellular automatons.
08:00:47 <Taneb> I was going for a cellular automaton definition
08:01:00 <Taneb> Which is then run with the starting state of the input
08:01:13 <Taneb> For a defined number of steps
08:01:16 <itidus20> humm cellular automatons...
08:01:21 <itidus20> do cells exist?
08:01:29 <CakeProphet> what?
08:01:50 <itidus20> does a cell exist? :P
08:01:55 <CakeProphet> what kind of cell.
08:02:02 <itidus20> a game of life cell
08:02:09 <CakeProphet> uh, sure.
08:02:18 <itidus20> well, do infinite cells exist?
08:02:28 <CakeProphet> in the game of life, yes.
08:02:37 <Taneb> Only in the abstraction of the cellular automaton
08:02:58 <itidus20> if noone is capable of perceiving infinite cells then how can it be proven that they exist :D
08:03:19 <Taneb> It's an abstraction. They exist by definition
08:03:20 <itidus20> sorry im being dumb, and then being dumber
08:03:30 <itidus20> its overcompensation for not being a math guy
08:03:36 <itidus20> ahh
08:04:09 <itidus20> where i was going with this was: if something exists by definition... do you ever need to actually calculate all the cells in order to use all the cells?
08:04:30 <Taneb> No
08:04:47 <Taneb> Pedantic people would say it's unbounded rather than infinite
08:05:02 <itidus20> well you can have infinite dead cells
08:05:03 <CakeProphet> data CA t = CA {left :: [t], right :: [t], up :: [t], down :: [t], current :: t}
08:05:04 <itidus20> :D
08:05:39 <CakeProphet> data GoLState = Alive | Dead
08:05:39 <itidus20> you can speak with accuracy about an infinte plane of dead cells 8->
08:05:57 <CakeProphet> GameOfLifeInitialState = CA (repeat Dead) (repeat Dead) (repeat Dead) (repeat Dead) Dead
08:06:25 <Taneb> If you were a live cell on infinite n-dimensional planes of dead cells, it'd be kinda creepy
08:06:28 <CakeProphet> er... no.
08:06:29 <CakeProphet> what am I doing.
08:06:38 <CakeProphet> lol that just makes a cross-shaped automaton.
08:06:52 <itidus20> Taneb: maybe you are.. thats why its creepy
08:07:28 <Taneb> O dee mee!
08:07:32 <CakeProphet> I'm not entirely sure how to represent a zipper in 2D
08:07:41 <CakeProphet> a zipper of zippers?
08:07:57 <itidus20> its elegant looking code you have there anyway
08:08:03 <Taneb> I'm suspecting recursion is the answer
08:08:24 <CakeProphet> well, yes. repeat is how I generate the infinite list, and repeat is recursive.
08:08:24 <itidus20> i must remember to not forget about studying haskell
08:08:50 <CakeProphet> repeat x = x : repeat x
08:09:19 <CakeProphet> or fix (x:) :P
08:11:33 <CakeProphet> okay so I'd have data Zipper t = Zipper {left :: [t], right :: [t], current :: t}
08:11:55 <CakeProphet> and then type CA t = Zipper (Zipper t)
08:12:49 <CakeProphet> then I could define shiftLeft, shiftRight, shiftUp, shiftDown.
08:15:22 <Taneb> brb
08:16:16 <monqy> I think I've seen a zipper in 2d before
08:16:20 <monqy> I may be misremembering though
08:17:24 <CakeProphet> the problem with defining it as a zipper of zippers is that each sub-zipper has its own cursor or whatever its called.
08:17:30 <CakeProphet> which is not quite what I want.
08:20:13 <monqy> I indeed misremembered. oops.
08:20:45 <CakeProphet> I suppose you could map the shift operation to each sub-zipper whenever you move left/right
08:21:04 <CakeProphet> but that seems pretty inefficient.
08:21:19 <CakeProphet> just a little bit
08:23:53 -!- monqy has quit (Quit: hello).
08:24:00 <Taneb> Back
08:43:47 -!- Taneb has quit (Ping timeout: 252 seconds).
08:45:59 <CakeProphet> !perl print 2 >> 1
08:46:01 <EgoBot> 1
08:46:08 <CakeProphet> !perl print 3 >> 1
08:46:08 <EgoBot> 1
08:49:37 <CakeProphet> oh hey I've found a use for bitwise shift.
08:51:53 <CakeProphet> you would use it when constructing a hidden message from the least significant bits of some other data.
08:55:51 -!- azaq231 has joined.
08:57:25 -!- azaq23 has quit (Ping timeout: 276 seconds).
08:58:46 <fizzie> That sounds a bit unlikely, given that you don't need a bitshift to set, clear or extract the least significant bit.
08:59:19 <fizzie> (Assuming you have bitwise ands and ors and the other usual fluff.)
09:00:10 <fizzie> Oh, you meant for putting the bits together, I guess.
09:07:48 <CakeProphet> The fact that Java is one of the most popular languages out there
09:07:56 <CakeProphet> and has absolutely no support for higher-order functions
09:07:58 <CakeProphet> baffles me.
09:08:43 <CakeProphet> fizzie: and right, putting them together with and requires shifting the bits to the right location.
09:08:57 <CakeProphet> well... with or actually.
09:09:16 <CakeProphet> extracting with and.
09:09:53 * CakeProphet should implement class-based versions of map and filter in Java.
09:09:58 <fizzie> Lambdas are coming in Java 8.
09:10:03 <CakeProphet> you have to use an anonymous class everytime.
09:10:33 <CakeProphet> fizzie: so I'm assuming support for lambdas also includes support for function types?
09:10:41 <fizzie> Nno, of course not. :p
09:10:56 <fizzie> It's mostly just a syntactic thing to make the anonymous-class solution less verbose.
09:10:56 <CakeProphet> otherwise you'd just define the lambda and it would uh... sit there and do nothing.
09:11:02 <CakeProphet> ..oh, really? damnit.
09:11:18 <CakeProphet> at least C# has delegates, I mean really.
09:11:18 <fizzie> The lambda types are "convertible" to any class with a single public method that has a compatible parameter list, approximately.
09:11:23 <fizzie> (Glossing over the details here.)
09:11:27 <CakeProphet> that's so stupid.
09:11:45 <CakeProphet> they should just steal delegates and call it something else.
09:12:09 <fizzie> I would suppose it's so that you can actually use the lambdas in all the existing APIs that have been written to take objects implementing single-method interfaces.
09:12:20 <fizzie> Runnable and such.
09:12:32 <CakeProphet> well right, but they could also just add new constructors for those methods that take lambda parameters.
09:12:37 <CakeProphet> *for those classes
09:13:12 <fizzie> But you can't add to Java interfaces.
09:13:29 <fizzie> Existing ones, I mean. Because otherwise all existing implementations would start complaining about missing methods.
09:13:53 <fizzie> So you can't put anything new in the Collection<T> interface for example, without ruining everyone else's collections.
09:14:10 <CakeProphet> so lame.
09:14:25 <CakeProphet> C# actually has a pretty well-thought out standard API.
09:15:02 <fizzie> That's I think why the have the Collections class with all those static methods, because you can easily stick stuff in there. (Except of course you can't then override that stuff in custom-built containers or anything.)
09:15:30 <fizzie> (There's also a proposal for "extension methods" that would work around the above thing up to some degree, not sure if that's planned for Java 8 too.)
09:15:42 <CakeProphet> Func<> for example... which has a bunch of overloads. Func<ReturnType>, Func<A,ReturnType>, Func<A,B,ReturnType>.
09:15:50 <CakeProphet> And then you use Action<> if the return type is void.
09:17:35 <CakeProphet> basically it's just an alternative to writing your own delegate types.
09:18:35 <CakeProphet> delegate int FrameWorkManagerCallBackEnterpriseyCruft(int a, int b)
09:19:01 <CakeProphet> and then you can declare variables of type FrameWorkManagerCallBackEnterpriseyCruft, and assign any method that matches that signature.
09:19:15 <CakeProphet> variables/method parameters
09:20:29 <CakeProphet> also += will append methods to a list that is executed when the delegate variable is called. Which I'm sure makes writing event-based code ridiculously simple.
09:21:02 <fizzie> But you need to explicitly test against an empty delegate list when calling, IIRC.
09:21:19 <CakeProphet> oh you do?
09:22:01 <CakeProphet> ah yes
09:22:06 <fizzie> Yes. It's always "if (blah != null) blah();" in all code that wants to call all the blah-handlers.
09:22:27 <CakeProphet> you have to test for null. Though some people on Stack Overflow recommend adding an empty method to remove that check.
09:23:00 <CakeProphet> Stack Overflow = reliable community of programming masters.
09:23:45 <CakeProphet> you could also use the poorly named "null-coalescing operator" and write blah?? blah()
09:25:27 <CakeProphet> but yeah "you have to test for null a lot" is a common annoyance of many languages that have nullable types.
09:25:34 <fizzie> That's what confused-looking operator.
09:26:09 <CakeProphet> yes I prefer Perl's //, but that's because I'm a Perl fanboy.
09:26:23 <CakeProphet> it does the exact same thing.
09:27:26 <CakeProphet> erkwerjwejr
09:27:34 <CakeProphet> // is probably Perl's most important contribution to the future of OO programming. :P
09:27:54 <CakeProphet> but C# will get all of the credit. :(
09:28:28 <CakeProphet> all the former Java programmers switching to C# will be like "woah that's probably the best idea for an operator ever, C# designers."
09:28:29 <fizzie> // is also a bit silly-looking. What, it's the || except on a windy day? (Still, I suppose they're running out of sensible operators.)
09:29:01 <CakeProphet> yeah I'm not really sure about the choice of symbol. I suppose ?? actually kind of makes some sense.
09:29:45 <CakeProphet> still, an operator is just a sequence of symbols. They're not really suggestive by themselves. Only through convention do you associate || with or in the first place.
09:29:46 <fizzie> I vaguely recall that some drafts of Perl 6 made the ternary operator be "$a ?? $b :: $c", doubling the ? and : for some reason.
09:30:01 <CakeProphet> that's weird.
09:30:16 <CakeProphet> Perl 6 is destroying Perl's golfability. :P
09:31:07 <CakeProphet> too many characters to do things.
09:31:46 <CakeProphet> more than 4 characters for a function/method name or 2 characters for a symbolic operator is unacceptable.
09:32:33 <fizzie> So <=> is unacceptable?-)
09:32:43 <CakeProphet> totally.
09:33:07 <CakeProphet> however, cmp is acceptable.
09:33:09 <CakeProphet> make sense?
09:33:21 <fizzie> "Sure, whatev."
09:34:25 <CakeProphet> I should rewrite Haskell's Prelude for golfing.
09:34:42 <CakeProphet> have everything with very short names, and any two-argument functions as operators.
09:35:16 <CakeProphet> > id
09:35:17 <lambdabot> Overlapping instances for GHC.Show.Show (a -> a)
09:35:17 <lambdabot> arising from a use of `...
09:35:20 <CakeProphet> > id + id
09:35:21 <lambdabot> Overlapping instances for GHC.Show.Show (a -> a)
09:35:21 <lambdabot> arising from a use of `...
09:35:33 <CakeProphet> caleskell is interesting.
09:35:51 <CakeProphet> :t id - id
09:35:52 <lambdabot> forall a. (Num a) => a -> a
09:36:01 <CakeProphet> what does that even do.
09:37:10 <fizzie> > id - id $ 42
09:37:10 <lambdabot> 0
09:37:16 <fizzie> Verily.
09:37:57 <CakeProphet> > id - id $ True
09:37:57 <lambdabot> No instance for (GHC.Num.Num GHC.Bool.Bool)
09:37:57 <lambdabot> arising from a use of `GHC.N...
09:38:06 <fizzie> I suppose it does the other "intuitive" thing when summing.
09:38:10 <fizzie> > id + id $ 42
09:38:10 <CakeProphet> yes.
09:38:12 <lambdabot> 84
09:38:14 <fizzie> Right.
09:38:43 <CakeProphet> makes writing pointlessly easy.
09:38:59 <CakeProphet> > map ((*2) + (*4)) [1..]
09:39:00 <lambdabot> [6,12,18,24,30,36,42,48,54,60,66,72,78,84,90,96,102,108,114,120,126,132,138...
09:39:39 <CakeProphet> > 2*sin
09:39:39 <lambdabot> Overlapping instances for GHC.Show.Show (a -> a)
09:39:39 <lambdabot> arising from a use of `...
09:39:40 <CakeProphet> lol
09:39:52 <CakeProphet> > const 2*sin 4
09:39:53 <lambdabot> Overlapping instances for GHC.Show.Show (b -> t)
09:39:53 <lambdabot> arising from a use of `...
09:40:08 <CakeProphet> > (const 2*sin) 4
09:40:09 <lambdabot> -1.5136049906158564
09:40:20 <CakeProphet> awww yeah signal processing.
09:45:48 <CakeProphet> okay so I'm wondering if it would be bad to use the same seed value everytime I want to generate white noise...
09:46:05 <CakeProphet> because otherwise I would have to use IO to generate a white noise signal.
09:46:32 <CakeProphet> I guess I could just pass the seed parameter to the generator...
09:48:42 <CakeProphet> I'm pretty sure using the same seed everytime would not degrade the quality of the white noise produced, at least to the human ear.
09:49:20 <CakeProphet> so I'll have one with a seed parameter, one without, and one that is in IO
09:50:08 <CakeProphet> and by "write" I mostly mean "use the ones that are already there"
10:01:22 <CakeProphet> @hoogle a -> [a]
10:01:22 <lambdabot> Prelude repeat :: a -> [a]
10:01:22 <lambdabot> Data.List repeat :: a -> [a]
10:01:22 <lambdabot> Prelude iterate :: (a -> a) -> a -> [a]
10:02:56 <CakeProphet> > iterate succ >=> iterate pred $ 1
10:02:57 <lambdabot> [1,0,-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20...
10:03:17 <CakeProphet> > iterate succ >=> take 3 . iterate pred $ 1
10:03:19 <lambdabot> [1,0,-1,2,1,0,3,2,1,4,3,2,5,4,3,6,5,4,7,6,5,8,7,6,9,8,7,10,9,8,11,10,9,12,1...
10:29:47 -!- itidus20 has quit (Ping timeout: 264 seconds).
10:32:50 -!- itidus20 has joined.
10:32:55 -!- Wamanuz has quit (Remote host closed the connection).
10:36:37 -!- Wamanuz has joined.
10:59:00 -!- augur has quit (Remote host closed the connection).
10:59:11 -!- augur has joined.
11:17:34 -!- FireFly has joined.
11:58:08 -!- ais523 has joined.
12:08:21 -!- benuphoenix has joined.
12:08:58 <benuphoenix> anyone have the ruleset for the irc-based nomic called Canada?
12:10:11 <ais523> I don't, and the other two people who might plausibly have it (elliott and Vorpal) aren't here right now
12:11:01 <Sgeo> comex_ wouldn't plausibly have it?
12:12:21 <ais523> hmm, I can't remember if he was around back then
12:15:00 <benuphoenix> comex was there
12:41:19 <itidus20> i wonder if a wireless network messaging protocol would be a slightly good thing, or a very very bad thing
12:42:59 <itidus20> nvm
13:45:35 <ais523> hey, does Befunge-98 have any libraries/fingerprints for doing object-oriented programming yet?
13:47:12 <ais523> the topic came up in another channel
13:54:44 <fizzie> There's FOBJ in the RC/Funge, it's sort-of like that.
13:54:47 <fizzie> http://www.rcfunge98.com/rcfunge2_manual.html#FOBJ
13:55:09 <CakeProphet> :t shiftL
13:55:09 <lambdabot> forall a. (Bits a) => a -> Int -> a
13:55:26 <ais523> fizzie: ah, that's what I was looking for
13:55:31 <itidus20> MoL yeah.. MoL yeah..
13:55:47 <CakeProphet> :t (|)
13:55:47 <lambdabot> parse error on input `|'
13:56:06 <CakeProphet> er whats bitwise or?
13:59:36 -!- benuphoenix has quit (Quit: leaving).
14:00:07 <CakeProphet> @hoogle Bits
14:00:07 <lambdabot> module Data.Bits
14:00:07 <lambdabot> Data.Bits class Num a => Bits a
14:00:07 <lambdabot> Data.Bits bitSize :: Bits a => a -> Int
14:00:11 <fizzie> .|., isn't it?
14:00:15 <CakeProphet> ah
14:00:18 <CakeProphet> :t (.|.)
14:00:19 <lambdabot> forall a. (Bits a) => a -> a -> a
14:00:24 <CakeProphet> :t (.&.)
14:00:25 <lambdabot> Ambiguous occurrence `.&.'
14:00:25 <lambdabot> It could refer to either `Data.Bits..&.', imported from Data.Bits
14:00:25 <lambdabot> or `Test.QuickCheck..&.', imported from Test.QuickCheck
14:00:32 <fizzie> Looks like a middle finger.
14:00:36 <itidus20> (o Y o)
14:00:55 <CakeProphet> :t (Data.Bits.(.&.))
14:00:55 <lambdabot> Couldn't find qualified module.
14:01:10 <CakeProphet> :t (Data.Bits..&.)
14:01:11 <lambdabot> forall a. (Bits a) => a -> a -> a
14:01:19 <CakeProphet> that syntax is weird to me.
14:01:39 <CakeProphet> > 3 Data.Bits..&. 4
14:01:39 <lambdabot> Ambiguous type variable `a' in the constraint:
14:01:39 <lambdabot> `Data.Bits.Bits a'
14:01:39 <lambdabot> a...
14:01:50 <CakeProphet> > 3 Data.Bits..&. 4 :: Int
14:01:51 <lambdabot> 0
14:03:11 <fizzie> Prettiest thing since sliced bread.
14:04:25 <CakeProphet> :t (.^.)
14:04:25 <lambdabot> Not in scope: `.^.'
14:04:29 <CakeProphet> er, what's xor?
14:04:39 <CakeProphet> @hoogle (Bits a) => a -> a -> a
14:04:39 <lambdabot> Data.Bits (.&.) :: Bits a => a -> a -> a
14:04:39 <lambdabot> Data.Bits (.|.) :: Bits a => a -> a -> a
14:04:39 <lambdabot> Data.Bits xor :: Bits a => a -> a -> a
14:05:52 <CakeProphet> > let mul a b = if a == 0 then b else let c = b Data.Bits..&. a in mul (c `shiftL` 1) (b `xor` a) in mul 8 8
14:05:52 <lambdabot> Ambiguous type variable `a' in the constraint:
14:05:52 <lambdabot> `Data.Bits.Bits a'
14:05:53 <lambdabot> a...
14:06:11 <CakeProphet> > let mul :: Int -> Int -> Int; mul a b = if a == 0 then b else let c = b Data.Bits..&. a in mul (c `shiftL` 1) (b `xor` a) in mul 8 8
14:06:11 <lambdabot> 16
14:06:18 <CakeProphet> ..not quite.
14:07:51 <CakeProphet> oh wait I think I defined addition actually.
14:07:59 <CakeProphet> > let mul :: Int -> Int -> Int; mul a b = if a == 0 then b else let c = b Data.Bits..&. a in mul (c `shiftL` 1) (b `xor` a) in add 2 2
14:08:00 <lambdabot> Not in scope: `add'
14:08:14 <CakeProphet> > let add :: Int -> Int -> Int; add a b = if a == 0 then b else let c = b Data.Bits..&. a in add (c `shiftL` 1) (b `xor` a) in add 2 2
14:08:14 <lambdabot> 4
14:08:18 <CakeProphet> yep
14:09:13 <CakeProphet> now to make it look better.
14:12:12 <CakeProphet> > let add :: Int -> Int -> Int; add 0 b = b; add a b = let c = b Data.Bits..&. a in add ((`shiftL` 1) . b Data.Bits..&. a) (b `xor` a) in foldl1 add [1..100]
14:12:13 <lambdabot> Couldn't match expected type `f a'
14:12:13 <lambdabot> against inferred type `GHC.Types...
14:12:34 <CakeProphet> > let add :: Int -> Int -> Int; add 0 b = b; add a b = let c = b Data.Bits..&. a in add ((`shiftL` 1) . (b Data.Bits..&. a)) (b `xor` a) in foldl1 add [1..100]
14:12:35 <lambdabot> Couldn't match expected type `f a'
14:12:35 <lambdabot> against inferred type `GHC.Types...
14:13:36 <CakeProphet> oh right
14:14:15 <CakeProphet> > let add :: Int -> Int -> Int; add 0 b = b; add a b = let c = b Data.Bits..&. a in add ((b Data.Bits..&. a) `shiftL` 1) (b `xor` a) in foldl1 add [1..100]
14:14:15 <lambdabot> 5050
14:18:50 <CakeProphet> > let add :: Int -> Int -> Int; add 0 b = b; add a b = add ((b Data.Bits..&. a) `shiftL` 1) (b `xor` a) in foldl1 add [1..100]
14:18:51 <lambdabot> 5050
14:18:55 <CakeProphet> forgot to remove the let.
14:28:03 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
14:34:49 <fizzie> The wurst multiplier:
14:34:52 <fizzie> > let mul :: Int -> Int -> Int; mul a b = let i = [0 .. (bitSize a - 1)] in sum $ map (\i -> if testBit a i then b `shiftL` i else 0) i in mul 17 19
14:34:52 <lambdabot> 323
14:46:33 <Sgeo> My score playing Barbu: -289. Supposedly, this is good for someone playing for the first time
15:00:29 -!- copumpkin has joined.
15:22:31 <Sgeo> Dear website: Rejecting an email address due to capital letters is pants-on-head retarded.
15:24:06 <ais523> wow, that's stupid
15:24:12 <ais523> is your email provider case-insensitive?
15:24:27 <ais523> the bit after the @ is, the bit before the @ is up to the provider but the vast majority interpret it as case-insensitive
15:24:29 <Sgeo> Well, it was my dad trying to use the website
15:25:28 <Sgeo> It autocompletes with a capital in the first part. Before I proved to myself that that was the issue, I suggested it to him, but the... form thingy replaced the lower-case with the capital
15:25:33 <Sgeo> cpap.com
15:32:15 -!- chickenzilla has joined.
15:40:57 <Vorpal> <benuphoenix> anyone have the ruleset for the irc-based nomic called Canada?
15:40:57 <Vorpal> <ais523> I don't, and the other two people who might plausibly have it (elliott and Vorpal) aren't here right now
15:41:00 <Vorpal> uh...
15:41:01 <Vorpal> hm
15:41:07 <Vorpal> nope I don't think so
15:41:25 <Vorpal> I have no clue where to look even
15:58:05 -!- pikhq has joined.
15:58:19 -!- pikhq_ has quit (Ping timeout: 255 seconds).
16:06:31 -!- derrik has joined.
16:16:16 -!- oklopol has joined.
16:17:05 <oklopol> well what problem?
16:19:23 <oklopol> i mean the dynamic one
17:01:00 -!- copumpkin has quit (Quit: Leaving...).
17:01:25 -!- copumpkin has joined.
17:46:00 -!- copumpkin has quit (Ping timeout: 240 seconds).
17:46:46 -!- copumpkin has joined.
17:53:22 -!- copumpkin has quit (Ping timeout: 258 seconds).
18:06:47 -!- monqy has joined.
18:08:28 -!- copumpkin has joined.
18:16:35 <quintopia> yeah
18:34:14 <olsner> things I hate about eating chicken: the parts of the chicken consisting of mystery meat instead of chicken
18:36:53 <pikhq> Sounds like you're eating wyngz.
18:37:30 <derrik> i hate mystery meat
18:40:18 <olsner> unsure if all of it even counts as meat, but that's part of the mystery I guess
18:41:09 <oklopol> eating causes cancer
18:41:48 <olsner> cancer causes eating
18:42:16 <derrik> work kills.. everybody who has some some work has died
18:42:25 <derrik> *done some
18:42:38 <oklopol> working causes cancer
18:46:40 -!- derrik has left.
18:52:22 -!- GuestIceKovu has changed nick to Slereah.
19:12:02 -!- ais523 has quit (Remote host closed the connection).
19:44:43 -!- Taneb has joined.
19:44:56 <Taneb> Hello
19:46:12 <Taneb> Actually, change of plan
19:46:14 <Taneb> brb
19:46:56 -!- Sgeo has quit (Ping timeout: 255 seconds).
19:47:12 -!- zzo38 has joined.
19:51:38 -!- azaq231 has quit (Quit: Leaving.).
19:59:56 -!- Taneb has quit (Ping timeout: 252 seconds).
20:01:20 <tswett> Does anyone remember kilgame? I think it was created by pikhq or oklopol or lament or a similar person.
20:02:37 -!- Taneb has joined.
20:02:41 <Taneb> Hello
20:03:50 <zzo38> "Hello"
20:06:13 <Taneb> Well, things are happening in the world
20:09:16 <olsner> no, nothing is happening "in the world"
20:10:35 <Taneb> Yes they are
20:10:54 <Taneb> Convection currents are flowing around in the mantle
20:13:11 <Taneb> Also, it's happened again
20:15:23 <Taneb> I'm freakin' insane
20:31:33 -!- Sgeo has joined.
21:22:00 -!- Taneb has quit (Quit: Page closed).
21:38:32 -!- TeruFSX has joined.
21:42:09 -!- oerjan has joined.
21:45:51 <oklopol> hi oerjan
21:46:07 <oerjan> hi *hides behind rock*
21:46:17 <oklopol> you still don't remember my name?
21:46:48 <oerjan> det ville vært rart
21:47:07 <oklopol> i fucking tattooed it between my angle brackets just so people would remember it
21:47:48 <oerjan> well you've dropped one of them, i can see clearly there is no <
21:48:32 <oklopol> lemme check my mirror
21:48:44 <oklopol> [00:48:43] <oklopol> hi
21:48:44 <oklopol> [00:48:43] <oklopol> hi
21:48:45 <oklopol> [00:48:45] <oklopol> checking
21:48:45 <oklopol> [00:48:45] <oklopol> checking
21:48:46 <oklopol> no it's there
21:49:04 <oklopol> you must be going blind in one eye
21:49:46 <oerjan> AAAAAAAAAAAAAAAAA
21:55:20 <oklopol> i think i'll go blind in both eyes for a few hours now, see you tomorrow if it's temporary ->
21:57:18 <oerjan> O KAY
22:01:03 <oerjan> <CakeProphet> I'm not entirely sure how to represent a zipper in 2D
22:01:16 <oerjan> obviously he wants to start with a quadtree.
22:01:35 <oerjan> but now he'll NEVER know *MWAHAHAHA*
22:18:33 -!- MDude has joined.
22:19:25 -!- Nisstyre has quit (Ping timeout: 258 seconds).
22:20:19 -!- iamcal has quit (Remote host closed the connection).
22:45:33 <oerjan> that recent post on godel's lost letter seems to have brought up many quips in the comments...
22:46:13 <oerjan> 'In a discussion on Google+ on why it is superior to Twitter someone commented: “I would go so far as to say that almost any idea that can be expressed in 140 characters is too trivial, and not worth expressing."'
22:47:17 <oerjan> (the subject being "Self-defeating sentences")
22:48:33 -!- TeruFSX has quit (Ping timeout: 258 seconds).
22:49:29 -!- iamcal has joined.
22:52:06 -!- elliott has joined.
22:55:18 <elliott> suppe,
22:57:23 <oerjan> pannekaker med ertesuppe
22:57:36 <oerjan> (og bacon)
23:00:20 <elliott> 09:13:12: <fizzie> But you can't add to Java interfaces.
23:00:20 <elliott> 09:13:29: <fizzie> Existing ones, I mean. Because otherwise all existing implementations would start complaining about missing methods.
23:00:20 <elliott> 09:13:53: <fizzie> So you can't put anything new in the Collection<T> interface for example, without ruining everyone else's collections.
23:00:20 <elliott> 09:15:02: <fizzie> That's I think why the have the Collections class with all those static methods, because you can easily stick stuff in there. (Except of course you can't then override that stuff in custom-built containers or anything.)
23:00:27 <elliott> fizzie: see expression problem
23:01:07 <oerjan> java doesn't even _try_ to have a solution to it, i think.
23:01:47 <elliott> oerjan: um the expression problem was originally formulated and solved for GJ by its creators
23:01:53 <elliott> GJ = Generic Java, which was merged into Java in the fifth version
23:02:06 <elliott> the solution isn't how any Java code or libraries are structured, mind you
23:02:17 <oerjan> ok
23:02:45 <elliott> 09:45:48: <CakeProphet> okay so I'm wondering if it would be bad to use the same seed value everytime I want to generate white noise...
23:02:46 <elliott> this is what RandomR is for
23:02:47 <elliott> ?hoogle random
23:02:47 <lambdabot> package random
23:02:47 <lambdabot> System.Random random :: (Random a, RandomGen g) => g -> (a, g)
23:02:47 <lambdabot> module System.Random
23:02:51 <elliott> well RandomGen
23:03:04 <elliott> 12:08:58: <benuphoenix> anyone have the ruleset for the irc-based nomic called Canada?
23:03:04 <elliott> wow what
23:03:08 -!- iamcal has quit (Ping timeout: 255 seconds).
23:04:13 <elliott> 20:01:20: <tswett> Does anyone remember kilgame? I think it was created by pikhq or oklopol or lament or a similar person.
23:04:14 <elliott> yes; lament
23:04:17 <elliott> tswett:
23:04:55 -!- subleq has joined.
23:05:05 -!- subleq has left.
23:05:46 <elliott> hi subleq bye subleq
23:09:36 -!- subleq has joined.
23:09:41 <subleq> fine, i'll say hi
23:09:58 <elliott> hello
23:12:20 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
23:14:50 -!- CakeProphet has quit (Read error: Connection reset by peer).
23:15:14 -!- CakeProphet has joined.
23:16:24 <zzo38> Do you have idea what I (and my brother) might try next in D&D game I was playing?
23:20:03 <tswett> > fix (\xs -> flip concatMap xs (\x -> ' ' : case x of ' ' -> 'space'; _ -> x))
23:20:03 <lambdabot> <no location info>:
23:20:03 <lambdabot> lexical error in string/character literal at chara...
23:20:15 <tswett> > fix (\xs -> flip concatMap xs (\x -> ' ' : case x of ' ' -> "space"; _ -> [x]))
23:20:18 <lambdabot> mueval-core: Time limit exceeded
23:28:04 -!- subleq has quit (Quit: leaving).
23:30:16 <oerjan> > fix (\xs -> ' ' : flip concatMap xs ((++" ").(\x -> ' ' : case x of ' ' -> "space"; _ -> [x])))
23:30:18 <lambdabot> " space space s p a c e space space s p a c e space space ...
23:30:31 <oerjan> oops
23:30:43 <oerjan> > fix (\xs -> ' ' : flip concatMap xs ((++" ").(\x -> case x of ' ' -> "space"; _ -> [x])))
23:30:44 <lambdabot> " space s p a c e space s space p space a space c space e space s p a c e s...
23:32:02 <oerjan> tswett: ^ that what you wanted out?
23:32:06 -!- TeruFSX has joined.
23:32:16 <elliott> spaces of paces
23:32:17 <tswett> Yep.
23:33:12 <oerjan> > fix (\xs -> ' ' : unwords (flip concatMap xs (\x -> case x of ' ' -> "space"; _ -> [x])))
23:33:13 <lambdabot> Couldn't match expected type `[GHC.Types.Char]'
23:33:13 <lambdabot> against inferred ty...
23:33:16 <oerjan> oops
23:33:34 <oerjan> > fix (\xs -> ' ' : unwords (flip map xs (\x -> case x of ' ' -> "space"; _ -> [x])))
23:33:38 <lambdabot> mueval-core: Time limit exceeded
23:33:41 <oerjan> wat
23:34:16 <oerjan> why would that be different
23:34:50 <oerjan> > take 1 . unwords $ ('x':undefined) : undefined
23:34:51 <lambdabot> "*Exception: Prelude.undefined
23:34:54 <elliott> oerjan: you realise eval is non-deterministic?
23:34:58 <elliott> it could just be slow
23:35:02 <oerjan> > take 1 . unwords $ "x" : undefined
23:35:03 <lambdabot> "*Exception: Prelude.undefined
23:35:20 <oerjan> yes but i more suspect unwords is insufficiently lazy
23:35:25 <oerjan> @src unwords
23:35:25 <lambdabot> unwords [] = ""
23:35:25 <lambdabot> unwords ws = foldr1 (\w s -> w ++ ' ':s) ws
23:35:53 <oerjan> hm that doesn't look strict
23:37:51 <oerjan> > unwords $ "x" : undefined
23:37:52 <lambdabot> "*Exception: Prelude.undefined
23:38:21 -!- copumpkin has joined.
23:38:35 <oerjan> > let unwords [] = ""; unwords ws = foldr1 (\w s -> w ++ ' ':s) ws in unwords $ "x" : undefined
23:38:37 <lambdabot> "*Exception: Prelude.undefined
23:38:45 <oerjan> oh hm
23:39:29 <oerjan> > "x" ++ undefined
23:39:30 <lambdabot> "x*Exception: Prelude.undefined
23:39:41 <oerjan> > 'x' ++ undefined
23:39:41 <lambdabot> No instance for (Data.Monoid.Monoid GHC.Types.Char)
23:39:41 <lambdabot> arising from a use o...
23:39:46 <oerjan> oops
23:40:03 <oerjan> > "x" ++ ' ':undefined
23:40:05 <lambdabot> "x *Exception: Prelude.undefined
23:40:43 <oerjan> > let unwords ws = foldr1 (\w s -> w ++ ' ':s) ws in unwords $ "x" : undefined
23:40:45 <lambdabot> "*Exception: Prelude.undefined
23:41:31 <oerjan> > foldr1 (\w s -> w ++ ' ':s) $ "x" : undefined
23:41:33 <lambdabot> "*Exception: Prelude.undefined
23:41:53 <oerjan> > foldr1 (\w s -> w ++ b:s) $ [a] : undefined
23:41:54 <lambdabot> *Exception: Prelude.undefined
23:42:02 <oerjan> @src foldr1
23:42:02 <lambdabot> foldr1 _ [x] = x
23:42:02 <lambdabot> foldr1 f (x:xs) = f x (foldr1 f xs)
23:42:02 <lambdabot> foldr1 _ [] = undefined
23:42:18 <oerjan> ooh it's foldr1 which is not lazy of course
23:42:33 <oerjan> it needs to handle the exact [x] case specially
23:43:43 <oerjan> and by writing in terms of that, unwords becomes a tiny bit less lazy than necessary.
23:43:45 <elliott> world.c: In function ‘T.167’:
23:43:45 <elliott> world.c:246: error: ‘current_chunk$z’ may be used uninitialized in this function
23:43:45 <elliott> world.c:246: error: ‘current_chunk$x’ may be used uninitialized in this function
23:43:45 <elliott> world.c: In function ‘world_handle_chunk’:
23:43:45 <elliott> world.c:246: error: ‘current_chunk.z’ may be used uninitialized in this function
23:43:46 <elliott> world.c:246: error: ‘current_chunk.x’ may be used uninitialized in this function
23:43:50 <elliott> wow what
23:44:14 -!- iamcal has joined.
23:44:49 <oerjan> your shitty macros?
23:45:12 <oerjan> or wait, chunks, that's mc isn't it
23:47:26 <zzo38> I am trying to think of the next session of my D&D game. Maybe we should kick the stunned kuo-toas off of the ship, but maybe the wall is too high. Maybe we should ask them try to figure out where the ship is going and stuff, but maybe now they think we are crazy and won't tell us; we just have to wait. Maybe they need the uniform back, but the old clothes have been burned.
23:47:34 <zzo38> It is difficult.
23:50:36 <elliott> oerjan: mcmap, yes
23:50:42 <elliott> the dollar sign stuff was what wow'd me
23:50:46 <elliott> and the T.167.
23:56:19 -!- Taneb has joined.
23:56:24 <Taneb> Hello
23:57:12 <elliott> hi
23:58:19 * oerjan cackles evilly
23:58:21 <oerjan> i mean, hi
←2011-07-26 2011-07-27 2011-07-28→ ↑2011 ↑all