←2011-11-29 2011-11-30 2011-12-01→ ↑2011 ↑all
00:06:14 <elliott> 15:26:12 <tnks> is there a canonical example of an applicative functor that isn't a monad?
00:06:14 <elliott> 15:26:56 <tnks> or rather can't have a monad constructed around it.
00:06:14 <elliott> 15:29:51 <dmwit> tnks: ZipList
00:06:14 <elliott> 15:29:53 <hpc> tnks: ZipList
00:06:15 <elliott> AAAAAAARGH
00:06:27 <lambdabot> Consider it noted.
00:06:35 <elliott> @tell oerjan *OFDSIOFG
00:06:35 <lambdabot> Consider it noted.
00:12:14 -!- Jafet has joined.
00:20:17 -!- Nisstyre has joined.
00:21:52 <elliott> Phantom__Hoover
00:21:55 <elliott> Im disapointe in you
00:23:53 <shachaf> elliott: What?
00:23:56 <shachaf> ZipList join?
00:24:01 <elliott> Yes.
00:24:24 <shachaf> You can make such a thing?
00:24:36 <elliott> oerjan reckons he has.
00:24:37 -!- nooga has quit (Ping timeout: 260 seconds).
00:24:52 <elliott> It's basically just diagonalisation a la the reader monad, but tricksy because of the no guarantee of equal length.
00:25:18 <shachaf> Right, but I thought that was "tricksy" as in "impossible" because of that.
00:25:19 <elliott> (oerjan is sceptical that there are any Haskell ADTs that can be made applicative functors that can't be made monads (with the two instances agreeing))
00:25:34 <elliott> shachaf: Well, he wrote it out once in here I think and claimed it worked :P
00:26:04 <elliott> <elliott> (oerjan is sceptical that there are any Haskell ADTs that can be made applicative functors that can't be made monads (with the two instances agreeing))
00:26:08 <elliott> Well, I suppose that's easily disprovable.
00:26:15 <elliott> But you need existential quantification.
00:44:23 -!- Jafet has quit (Quit: Leaving.).
00:51:45 * Phantom__Hoover → sleep
00:51:54 <Phantom__Hoover> If only I had a way of indicating DEFCONery.
00:52:05 -!- Phantom__Hoover has quit (Quit: Leaving).
01:02:53 -!- Jafet has joined.
01:04:16 -!- Jafet has quit (Client Quit).
01:05:01 -!- Jafet has joined.
01:13:29 -!- Jafet has quit (Quit: Leaving.).
01:16:08 -!- xmorc has joined.
01:18:04 -!- xmorc has quit (Client Quit).
01:30:26 <pikhq_> https://upload.wikimedia.org/wikipedia/commons/b/bd/CricketBattingAverageHistogram.gif Wow.
01:40:25 <elliott> integration should be banned
01:41:40 <elliott> pikhq_: join me in "anti integration league"
01:41:45 <elliott> wait no that sounds racist
01:43:01 -!- pikhq has joined.
01:43:03 -!- pikhq_ has quit (Ping timeout: 240 seconds).
01:48:16 <elliott> pikhq: :(
01:55:46 <pikhq> elliott: ?
01:55:51 <elliott> <elliott> integration should be banned
01:55:51 <elliott> <elliott> pikhq_: join me in "anti integration league"
01:55:51 <elliott> <elliott> wait no that sounds racist
01:55:56 <pikhq> Ah.
01:56:03 <pikhq> Why should it be banned?
01:56:16 <elliott> It's icky. Also uncomputable.
01:56:53 <pikhq> ^in the general case
01:57:15 <elliott> pikhq: The general case including........... Newtonian physics
01:57:36 <pikhq> Um?
01:58:04 <elliott> Which means numeric approximations
01:58:06 <elliott> Which means pain :'(
01:59:28 <elliott> pikhq: ("Um?"?)
02:08:42 -!- Jafet has joined.
02:19:21 <elliott> > text $ "pikhq: (" ++ fix ("\"" ++) ++ "Um" ++ fix (++ "\"?") ++ ")"
02:19:26 <elliott> > var $ "pikhq: (" ++ fix ("\"" ++) ++ "Um" ++ fix (++ "\"?") ++ ")"
02:19:33 <elliott> WORK WITH ME HERE LAMBDABOT
02:19:38 <lambdabot> mueval-core: Time limit exceeded
02:19:38 <lambdabot> thread killed
02:19:53 <elliott> > "pikhq: (" ++ fix ("\"" ++) ++ "Um" ++ fix (++ "\"?") ++ ")"
02:19:58 <lambdabot> mueval-core: Time limit exceeded
02:20:10 <elliott> pah
02:33:03 -!- pikhq has quit (Ping timeout: 240 seconds).
02:33:09 -!- pikhq_ has joined.
03:10:47 -!- Jafet has quit (Quit: Leaving.).
03:11:26 -!- Jafet has joined.
03:46:42 <kallisti> > deriv (\x -> (+3) * x) (+4)
03:46:43 <lambdabot> Couldn't match expected type `a -> a'
03:46:43 <lambdabot> against inferred type `Data.N...
03:50:22 <Sgeo> Hmm!
03:50:44 <Sgeo> > ((cos^2) + (sin^2))
03:50:46 <lambdabot> Overlapping instances for GHC.Show.Show (a -> a)
03:50:46 <lambdabot> arising from a use of `...
03:50:49 <Sgeo> > ((cos^2) + (sin^2)) 5
03:50:50 <lambdabot> 0.9999999999999999
03:51:17 <elliott> :t deriv (\x -> (+3) * x)
03:51:18 <lambdabot> Couldn't match expected type `a -> a'
03:51:18 <lambdabot> against inferred type `Dif a1'
03:51:18 <lambdabot> In the second argument of `(*)', namely `x'
03:51:29 <Sgeo> > deriv (\x -> (+3) * x) (+4) 10
03:51:31 <lambdabot> Couldn't match expected type `a -> a'
03:51:31 <lambdabot> against inferred type `Data.N...
03:51:43 <elliott> @env
03:51:43 <lambdabot> Maybe you meant: v wn
03:51:47 <elliott> bleh /me finds L.hs
03:51:54 <elliott> gotta track down where deriv is from so I know what the constructor is
03:52:42 <elliott> http://hackage.haskell.org/packages/archive/numbers/2009.8.9/doc/html/Data-Number-Dif.html
03:53:19 <elliott> :t deriv (\x -> df (+3) (deriv (+3)) * x)
03:53:20 <lambdabot> The section `+ 3' takes one argument,
03:53:21 <lambdabot> but its type `Dif a' has none
03:53:21 <lambdabot> In the first argument of `df', namely `(+ 3)'
03:53:31 <elliott> er duh
03:53:43 <elliott> :t deriv (\x -> df (+3) 1 * x)
03:53:44 <lambdabot> The section `+ 3' takes one argument,
03:53:44 <lambdabot> but its type `Dif a' has none
03:53:44 <lambdabot> In the first argument of `df', namely `(+ 3)'
03:53:46 <elliott> oops
03:53:51 <elliott> :t (\x -> df (+3) 1 * x)
03:53:52 <lambdabot> The section `+ 3' takes one argument,
03:53:52 <lambdabot> but its type `Dif a' has none
03:53:52 <lambdabot> In the first argument of `df', namely `(+ 3)'
03:53:58 <elliott> oh!
03:54:00 <elliott> :t deriv (\x -> mkDif (+3) 1 * x)
03:54:01 <lambdabot> forall a. (Num a) => (a -> a) -> a -> a
03:54:07 <elliott> > deriv (\x -> mkDif (+3) 1 * x) (+4)
03:54:08 <lambdabot> Overlapping instances for GHC.Show.Show (a -> a)
03:54:08 <lambdabot> arising from a use of `...
03:54:09 <elliott> kallisti: ^
03:54:23 <Sgeo> :t mkDif
03:54:24 <lambdabot> forall a. a -> Dif a -> Dif a
03:55:22 <Sgeo> I don't see what's wrong with kallisti's original thing?
03:55:46 <elliott> the types don't work
03:55:50 <elliott> (+3) does not match (Dif _)
03:55:53 <elliott> because it's (_ -> _)
03:56:55 <kallisti> ah right
03:56:59 <kallisti> can't do fromInteger magic there.
03:57:12 <elliott> > deriv (\x -> mkDif (+3) 1 * x) (+4) pi
03:57:13 <lambdabot> *Exception: (==): No overloading for function
03:57:17 <elliott> A+
03:57:31 * elliott doesn't know why that doesn't work.
03:57:44 <elliott> :t deriv (\x -> mkDif (+3) 1 * x) (+4) pi
03:57:45 <lambdabot> forall a. (Floating a) => a
04:30:20 <kallisti> elliott: I'm guessing pi for (->) is const pi?
04:30:36 <elliott> it couldn't exactly be anything else
04:31:15 <Sgeo> Ah
04:31:38 * elliott has no idea why the deriv thing there invokes ==
04:32:53 <kallisti> > mkDif (+3) 1
04:32:54 <lambdabot> Overlapping instances for GHC.Show.Show (a -> a)
04:32:54 <lambdabot> arising from a use of `...
04:32:58 <kallisti> > mkDif (+3) 1 * pi
04:32:59 <lambdabot> Overlapping instances for GHC.Show.Show (a -> a)
04:32:59 <lambdabot> arising from a use of `...
04:33:19 <Sgeo> > deriv (\x -> (+ (Dif 3)) * x) (+4)
04:33:20 <lambdabot> Not in scope: data constructor `Dif'
04:33:21 <kallisti> maybe it checks the output for some reason?
04:33:25 <kallisti> Sgeo: ...
04:33:32 <Sgeo> > deriv (\x -> (+ (Dif 3 0)) * x) (+4)
04:33:34 <lambdabot> Not in scope: data constructor `Dif'
04:33:40 <Sgeo> > deriv (\x -> (+ (D 3 0)) * x) (+4)
04:33:41 <lambdabot> Not in scope: data constructor `D'
04:35:54 <kallisti> I believe in you Sgeo.
04:36:02 <kallisti> I believe in your ability to read previous lines of code.
04:36:08 <Sgeo> :t mkDif
04:36:09 <lambdabot> forall a. a -> Dif a -> Dif a
04:36:15 <kallisti> Sgeo: yesssss!
04:36:18 <kallisti> triumph!
04:37:03 <Sgeo> :t deriv
04:37:05 <lambdabot> forall a b. (Num a, Num b) => (Dif a -> Dif b) -> a -> b
04:38:31 <kallisti> "Now we're told that coyotes don't TYPICALLY eat children" -- local CBS news
04:40:57 <elliott> wow
04:41:22 <kallisti> elliott: there are apparently some coyotes in Atlanta's parks
04:41:26 <kallisti> (park? I don't know)
04:46:03 <Sgeo> kallisti, elliott update
04:46:45 <quintopia> there are lots of parks
04:47:08 <quintopia> if any has coyotes, i'd bet on palisades
04:47:19 <quintopia> its just a forest
04:49:24 <kallisti> ..no
04:50:29 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
04:53:35 -!- copumpkin has joined.
05:05:18 -!- Jafet has quit (Quit: Leaving.).
05:09:18 -!- zzo38 has joined.
05:24:07 <zzo38> Now I invented the functions: opencont, closecont, opencontT, closecontT
05:25:23 <Sgeo> o.O
05:26:11 <zzo38> opencont (Barrier a c) = Barrier (a, c) opencont; closecont (Barrier (a, c) f) = Barrier a $ closecont . f . c;
05:26:37 <Sgeo> Oh
05:26:47 * Sgeo still has no idea what barrier monads are
05:26:52 <elliott> nobody does
05:26:57 <zzo38> closecont . opencont = id
05:27:31 <zzo38> Sgeo: Do you know about the generator functions (with yield) in JavaScript and in Python? Barrier monads is similar to that
05:27:41 <Sgeo> Ah
05:27:53 <Sgeo> Not familiar with JS, but am familiar with Python generator functions
05:28:21 <Sgeo> There's a Haskell library with yield somewhere
05:28:23 <zzo38> I think the JS and Python generator functions are similar to each other
05:32:31 -!- Sgeo has quit (Ping timeout: 244 seconds).
05:33:05 -!- Sgeo has joined.
05:36:30 <elliott> @pl \f xs -> tail xs ++ [f xs]
05:36:30 <lambdabot> liftM2 (++) tail . flip flip [] . ((:) .)
05:36:33 <elliott> @t \f xs -> tail xs ++ [f xs]
05:36:34 <lambdabot> Maybe you meant: tell thank you thanks thx ticker time todo todo-add todo-delete topic-cons topic-init topic-null topic-snoc topic-tail topic-tell type . ? @ ft v
05:36:35 <elliott> @ty \f xs -> tail xs ++ [f xs]
05:36:38 <lambdabot> forall a. ([a] -> a) -> [a] -> [a]
05:36:43 <elliott> @. hoogle ty \f xs -> tail xs ++ [f xs]
05:36:44 <lambdabot> Plugin `compose' failed with: Unknown command: "ty"
05:36:47 <elliott> @. hoogle type \f xs -> tail xs ++ [f xs]
05:36:48 <lambdabot> Parse error:
05:36:48 <lambdabot> forall a. ([a] -> a) -> [a] -> [a]
05:36:48 <lambdabot>
05:36:55 <elliott> @hoogle ([a] -> a) -> [a] -> [a]
05:36:55 <lambdabot> Foreign.Marshal.Utils withMany :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
05:36:56 <lambdabot> Data.Generics.Aliases ext1Q :: (Data d, Typeable1 t) => (d -> q) -> (forall e. Data e => t e -> q) -> d -> q
05:41:43 <Sgeo> zzo38, http://hackage.haskell.org/packages/archive/generator/0.5.4/doc/html/Control-Monad-Generator.html
05:43:13 <elliott> um
05:43:17 <elliott> Sgeo: isn't that just Writer
05:43:18 <elliott> except stupid
05:43:43 <pikhq_> Life is weird at times.
05:43:52 <pikhq_> https://upload.wikimedia.org/wikipedia/commons/3/3d/Ventricaria_ventricosa.JPG That's a fucking single-celled life form.
05:44:21 <pikhq_> They typically are 1-4 centimeters in diameter.
05:45:05 <Sgeo> I take it that Barrier is more like Python's abilities to pass in arguments to a generator?
05:45:26 <Sgeo> Or, actually, even getting items out one at a time makes sense, doesn't it... no, it does not
05:45:38 <Sgeo> Except as an already existing monad
05:45:57 <Sgeo> Will laziness cause the writer monad to also pause?
05:46:09 <Sgeo> If I only ask for the log
05:46:28 <elliott> "pause"?
05:46:53 <Sgeo> elliott, as in, not continuing to compute past, say, the first tell until I ask for the next item in the list
05:47:13 <elliott> how could it compute things you didn't force
05:47:55 <Sgeo> What was the other function used with the Writer monad
05:48:32 <zzo38> In JavaScript, there is a function g.send(x) that sends x to the result of yield inside of the generator function
05:48:48 <Sgeo> zzo38, Python has something similar
05:49:06 <Sgeo> And I guess that's what Barrier monads do?
05:49:40 <Sgeo> "The Monad: and other essays upon the higher consciousness - Google Books Result"
05:49:40 -!- kallisti_ has joined.
05:49:49 <Sgeo> "The sceptic erects a barrier round himself by his aggressive unbelief — a barrier which it is not worth the while of the non-physical entity to pierce ..."
05:50:15 <zzo38> Sgeo: Yes, it does that. This is the definition: data Barrier f b t = Unit t | Barrier f (b -> Barrier f b t) | Fail String; yield :: f -> Barrier f b b; yield = flip Barrier Unit;
05:51:45 -!- kallisti has quit (Ping timeout: 245 seconds).
05:51:58 <Sgeo> So f is the type of values that can be passed out of the Barrier monad, and b is the type that can go into it?
05:52:56 <zzo38> Sgeo: Yes.
05:53:07 <Sgeo> That's cool
05:53:14 <Sgeo> Is it on Hackage yet?
05:53:14 <Sgeo> >.>
05:53:33 <zzo38> Not yet. But I will put it on later.
05:54:20 <Sgeo> It vaguely reminds me of Iteratees, although Iteratees can only give one answer
05:54:26 <Sgeo> iirc
05:59:17 <zzo38> The function to make it to a list is collect :: Barrier f () t -> [f]
05:59:51 <zzo38> There is also reverse operation is uncollect :: [x] -> Barrier x a ()
06:02:45 <Sgeo> I'm trying to envision bind
06:03:12 <zzo38> I can tell you how I defined it if you want that
06:03:27 <Sgeo> Hmm, I guess if the thing on the left is a Barrier f (b -> Barrier f b t), the whole thing could be of that form
06:04:21 <Sgeo> But sure
06:05:15 <zzo38> Unit x >>= f = f x; Barrier a c >>= f = Barrier a $ c >=> f;
06:06:20 <Sgeo> That is far more concise than I could have written at first glance.
06:06:49 <Sgeo> I assume Fail a >>= _ = Fail a
06:06:50 <Sgeo> ?
06:07:04 <zzo38> Sgeo: Yes.
06:07:26 <zzo38> And there is instance of Alternative which is based on that.
06:07:36 -!- Jafet has joined.
06:07:42 * Sgeo is still a bit shaky on how Alternatives work in general
06:07:47 <Sgeo> Or what they're useful for
06:08:02 <Sgeo> Except parsing monads, ofc, but I don't understand how parsing monads work internally either
06:09:01 <Jafet> They allow parser embiggenment
06:09:29 <zzo38> They can be used with things other than parsers too.
06:10:13 -!- DCliche has joined.
06:11:42 <zzo38> Now I added a MonadPlus instance. However, it doesn't follow the right zero law but MonadPlus for many other monads also does not follow right zero law (but there are also many that do follow the right zero law).
06:12:01 <zzo38> empty = Fail []; Unit x <|> _ = Unit x; Fail y <|> x = annotateFail y x; Barrier a c <|> x = Barrier a $ \y -> (c y <|> x);
06:12:09 <zzo38> mzero = empty; mplus = (<|>);
06:13:46 -!- Klisz has quit (Ping timeout: 244 seconds).
06:13:53 <Sgeo> zzo38, when you were writing Barrier a c >>= f = Barrier a $ c >=> f, did you first write that c >=> f as something else?
06:14:11 <Sgeo> I guess I want reassurance that I don't need to catch things like that immediately
06:14:54 <zzo38> Sgeo: I did first write it like that, but maybe some other people might not (I don't know)
06:18:43 <Sgeo> zzo38, it should be possible to write crosstalk :: Barrier f b t1 -> Barrier b f t2 -> ([f],[b]), right?
06:19:45 <Sgeo> Wait, what if one wants to consume more than the other?
06:28:08 <zzo38> Sgeo: I have not thought of that function, but I might be able to. I suppose if one wants to consume more than the other, then you just use the shorter one
06:37:25 -!- pikhq has joined.
06:37:42 -!- pikhq_ has quit (Ping timeout: 252 seconds).
06:42:07 <elliott> @ask oklopol remember when you used to be stupid? <oklopol> j-invariant: actually i probably couldn't lecture all night, since the first nontrivial thing you usually do about CA is a theorem i actually don't know how to prove :D
06:42:08 <zzo38> I managed to do this: crosstalk :: Barrier f b t1 -> Barrier b f t2 -> [(f, b)]; crosstalk (Barrier a1 c1) (Barrier a2 c2) = (a1, a2) : crosstalk (c1 a2) (c2 a1); crosstalk _ _ = [];
06:42:08 <lambdabot> Consider it noted.
06:54:35 -!- DCliche has quit (Quit: You are now graced with my absence.).
07:01:36 <zzo38> crosstalkT :: (Functor m, Monad m) => BarrierT f b m t1 -> BarrierT b f m t2 -> m [(f, b)]; crosstalkT x y = liftM2 (liftA2 (,)) (runBarrierT (() <$ x)) (runBarrierT (() <$ y)) >>= either (const $ return []) (\((a1, c1), (a2, c2)) -> ((a1, a2) :) <$> crosstalkT (c1 a2) (c2 a1));
07:06:44 <zzo38> crosstalkT x y = liftM2 (liftA2 (,)) (runBarrierT ([] <$ x)) (runBarrierT ([] <$ y)) >>= either return (\((a1, c1), (a2, c2)) -> ((a1, a2) :) <$> crosstalkT (c1 a2) (c2 a1));
07:13:24 -!- GreaseMonkey has quit (Quit: The Other Game).
07:22:58 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
07:33:21 <kallisti_> @hoogle deriv
07:33:21 <lambdabot> package derivation-trees
07:33:21 <lambdabot> package derive
07:33:21 <lambdabot> package derive-gadt
07:33:32 <kallisti_> aw, mu-eval doesn't have those.
07:33:39 <kallisti_> :t deriv
07:33:40 <lambdabot> forall a b. (Num a, Num b) => (Dif a -> Dif b) -> a -> b
07:33:46 <kallisti_> @hoogle (Dif a -> Dif b) -> a -> b
07:33:47 <lambdabot> Warning: Unknown type Dif
07:33:47 <lambdabot> Data.Generics.Aliases ext1T :: (Data d, Typeable1 t) => (forall e. Data e => e -> e) -> (forall f. Data f => t f -> t f) -> d -> d
07:37:49 <elliott> kallisti_: i found the package earlier
07:39:06 <kallisti_> elliott: so you actually added it to lambdabot?
07:39:15 <elliott> ...no
07:39:34 <kallisti_> @src deriv
07:39:35 <lambdabot> Source not found. You speak an infinite deal of nothing
07:39:56 <kallisti_> elliott: also how does AD work in languages like C where there's no operator overloading.
07:40:03 <kallisti_> you said it could be used to differentiate C functions and the like.
07:40:09 <elliott> external tools
07:40:18 <elliott> in C++ they do horrible template hacks
07:41:39 <kallisti_> well duh
07:41:49 <kallisti_> that's how you do anything complex in C++
07:43:03 <kallisti_> does it require the C source?
07:43:07 <elliott> obviously
07:44:40 <kallisti_> elliott: who knows it could do some machine code hacks.
07:45:37 <kallisti_> elliott: so if you didn't add ad to lambdabot how is it there?
07:45:45 <elliott> lambdabot imports a fuckton of shit
07:45:52 <kallisti_> oh.
07:46:05 <kallisti_> hm, I guess mu-eval hasn't caught up or doesn't use the same imports.
07:46:10 <kallisti_> it's very picky about its imports.
07:50:40 <kallisti_> what's the name of the package that defines deriv?
07:51:27 <kallisti_> tried ad, fad, rad, and Data.Ring.Module.AutomaticDifferentiation but I don't think it's the same one
07:51:42 <elliott> kallisti_: stop attributing these things to mueval
07:51:44 <elliott> it is L.hs alone
07:52:52 <elliott> grr, I wish this glib queue had the property I want
07:53:30 <kallisti_> elliott: L.hs?
07:53:37 <elliott> kallisti_: see lambdabot sourec
07:57:24 <Sgeo> I think lists encode an at-most:
07:57:28 <kallisti_> Data.Number.Dif is commented out from the mueval source. :(
07:57:32 <Sgeo> [] fits the type [a], [[a]], etc.
07:57:43 <elliott> kallisti_: mueval is irrelevant
07:57:56 <kallisti_> elliott: ...to?
07:57:57 <Sgeo> Is there a way to encode at-least?
07:58:03 <elliott> kallisti_: the lambdabot imports
07:58:08 <elliott> Sgeo: i don't have any idea what you are talking about
07:58:10 <kallisti_> elliott: it's certainly relevant to what I'm talking about.
07:58:14 <kallisti_> which is not lambdabot
07:58:16 <kallisti_> it's mueval
07:58:28 <elliott> heh
07:58:44 <kallisti_> ..I mean, clearly lambdabot imports it.
07:58:47 <kallisti_> that wasn't the issue. :P
07:58:55 <Sgeo> [] fits the type [[[a]]], as do [[]] and [[[]]] and [[[[]]]] but [[[[[]]]]] does not
07:59:37 <Sgeo> (Typeclasses could be used to clean up that a, but I need to go to sleep soon)
07:59:56 <Sgeo> So [[[a]]] means "Accept at most [[[[]]]] but no numbers larger than that"
08:00:15 <Sgeo> (Treating these nested lists as numbers)
08:00:34 <Sgeo> I should go to sleep now, I have an exam tomorrow
08:01:53 <Sgeo> Hmm, I'd wonder if tuples are a better bet, but there are no one-element tuples
08:02:02 <Sgeo> ...and also, it wouldn't work, so n/m
08:02:40 <kallisti_> 1-tuples are a completely pointless thing.
08:02:49 <elliott> ugh, this sucks
08:03:15 <kallisti_> except newtypes I guess. newtypes are kind of like 1-tuples I guess.
08:03:33 <Sgeo> The point here is the nesting, though
08:04:10 <kallisti_> Just (Just (Just Nothing ) ) zomg
08:05:17 <Sgeo> That works just as well (or better), but which is easier to type?
08:05:27 <kallisti_> > Nothing :: Maybe ( Maybe ( Maybe a ) )
08:05:28 <lambdabot> Nothing
08:06:16 <Sgeo> What I'm curious about is if it's possible to encode at-least
08:06:20 <kallisti_> Sgeo: which is less broken. (not completely unbroken, but less broken at least)
08:06:37 <kallisti_> Sgeo: what does that even mean.
08:06:46 <kallisti_> (note: I read the explanation above; still confused)
08:06:52 <Sgeo> Values of a certain "value" or greater, as specified in the type, pass the type
08:06:56 <kallisti_> basically, what are you doing.
08:07:14 <Sgeo> What I currently have is values of a certain "value", or less, as specified in the type, pass the type
08:07:21 <Sgeo> So [] represents 0, for instance
08:07:36 <Sgeo> And passes [a], [[a]], [[[a]]], etc
08:07:39 <elliott> pikhq: Deewiant: I need a C language lawyer, ping
08:07:45 <Deewiant> Pong
08:08:03 <Sgeo> Whereas [[]] represents 1 and passes ... erm, [a], [[a]], [[[a]]]. Let's say that [[]] is 0
08:08:14 <Sgeo> [[[]]] passes.... ok, bluh
08:08:16 <kallisti_> elliott: I need a real lawyer; I may actually kill Sgeo.
08:08:19 <Sgeo> Let's start this again
08:08:21 <Deewiant> Sgeo: [[]] doesn't pass [a]
08:08:29 <elliott> Deewiant: Does C99 give enough guaranteed on accesses to a global volatile bool so that {x = false;} and {x = true;} are atomic with respect to "if (x)"
08:08:40 <Sgeo> [] doesn't fit the oh so heavy burden imposed by a?
08:08:48 <elliott> i.e. can I assume it works like an atomic shared bit for setting and testing
08:08:56 <elliott> (Setting to constants)
08:09:18 <Deewiant> "At sequence points, volatile objects are stable in the sense that previous accesses are complete and subsequent accesses have not yet occurred."
08:09:29 <Sgeo> Let's say that [] is 0. It passes [()], [[()]], [[[()]]], etc.
08:09:41 <kallisti_> > [[]] :: [a]
08:09:42 <lambdabot> Couldn't match expected type `a1' against inferred type `[a]'
08:09:43 <lambdabot> `a1' is a ...
08:09:53 <elliott> kallisti_: You can pass [[]] to a function expecting [a]
08:09:57 <elliott> Is I think Sgeo's point
08:10:05 <elliott> Deewiant: Alright. I still feel bad about using it.
08:10:13 <Sgeo> [[]] 1, by contrast, does not fit [()], but does fit [[()]], [[[()]]], etc.
08:10:41 <kallisti_> > let id :: [a] -> [a]; id x = x in id [[]]
08:10:43 <lambdabot> [[]]
08:10:50 <elliott> Deewiant: (I was hoping to eliminate the global volatile variable world_running from mcmap, but GLib doesn't offer something as simple as "a queue that you can disown so that pushes just do nothing" (or equivalent).)
08:11:00 <Sgeo> So, So, [[]] 1 is not at-most [()] 0
08:11:08 <elliott> Deewiant: (So removing world_running would cause every received world-relevant packet to leak memory in the queue.)
08:11:09 -!- oerjan has joined.
08:11:09 <Sgeo> (The former is the value, the latter is the type)
08:11:11 <elliott> (If the world's stopped.)
08:11:37 <Sgeo> So, [()] in the type means at-most 0. [[()]] in the type means at-most 1. etc.
08:11:50 <Deewiant> elliott: Can't you clear the queue at some later time?
08:12:00 <Sgeo> I'm still pondering potential usages of this, but I also have to wonder if there's a way to encode at-least.
08:12:01 <elliott> Deewiant: Clear it howso
08:12:11 <elliott> Deewiant: The point is that after the world thread ends, nobody is popping the queue
08:12:15 <elliott> But the proxy thread is still pushing
08:12:27 <Deewiant> When does this matter
08:12:47 <Deewiant> The world thread sounds like something important (note: I have no idea what the threads are for)
08:13:04 <Sgeo> kallisti_, is anything I'm saying making sense?
08:13:15 <elliott> Deewiant: When the world thread crashes in a predictable manner :)
08:13:32 <elliott> Deewiant: fizzie thought it important that the proxy continue to function even if the map and commands break
08:13:42 <Deewiant> elliott: And you want to keep the program running after this?
08:13:47 <elliott> ./world.c:stopf("chunk update decompression: inflateInit: %s", zError(err));
08:13:47 <elliott> ./world.c:stopf("chunk update decompression: inflate: %s", zError(err));
08:13:47 <elliott> ./world.c:stopf("broken decompressed chunk length: %d != %d and < %d",
08:13:47 <elliott> ./world.c:stopf("too high chunk update: %d..%d", y0, y0+ys-1);
08:13:53 <elliott> Basically it happens when chunk updates are fucked
08:14:02 <elliott> Deewiant: Well, it already does
08:14:09 <Vorpal> elliott: haven't Mojang fixed them?
08:14:18 <elliott> Deewiant: It works fine without even world_running, it just leaks memory
08:14:33 <kallisti_> Sgeo: um... I guess.
08:14:37 <elliott> Deewiant: I'd rather remove stop entirely or make it not leak memory and not use a volatile global
08:14:40 <kallisti_> but.. I don't know why you're doing that.
08:14:42 <elliott> I don't know how to achieve the latter
08:14:47 <Sgeo> kallisti_, BECAUSE I CAN
08:14:48 <Deewiant> elliott: What exactly works fine, what does the world thread do :-P
08:14:57 <Sgeo> (Also: Note: Practical usages still to be determined)
08:15:01 <elliott> Deewiant: Processes incoming world-relevant packets
08:15:08 <elliott> Deewiant: Map chunk updates, entity position updates, chat messages
08:15:19 <kallisti_> Sgeo: DUDE EITHER ENCODES LIKE..... LINKED LISTS
08:15:21 <Deewiant> elliott: Right, so, what exactly is still happening without the world thread
08:15:23 <elliott> Deewiant: Basically the world thread handles everything that isn't part of mcmap's fun ol' proxying/console regime
08:15:25 <elliott> Deewiant: Proxying
08:15:28 <elliott> Proxying and the console
08:15:34 <Vorpal> Deewiant: iirc it handles tracking of the world, for map display purposes and so on. Basically everything that isn't just "pass on to client/server"
08:15:35 <elliott> The map just freezes
08:15:45 <Deewiant> Right, hmh
08:15:50 <kallisti_> Sgeo: Either Int (Either Bool (Either (IO Awesome) ()))
08:15:55 <kallisti_> duuuuude think of the implications
08:16:04 <elliott> (The world thread is separate because fizzie thinks processing world packets might be slow; in reality the threading overhead almost certainly dwarfs it, but that's a battle for another day)
08:16:12 -!- nooga has joined.
08:16:23 <elliott> Deewiant: I get the feeling that a volatile global is The Way to do this, and if I want to avoid them I should use a super-high-level concurrency library
08:16:34 <elliott> Rather than glib's "here's some thread-starting functions... and a mutex... and a queue".
08:16:39 <elliott> "Have fun with that."
08:16:43 <Vorpal> heh
08:16:50 <elliott> (Heck, glib even has some operations on volatile pointers to lock bits atomically.)
08:17:09 <Vorpal> elliott: so are the glib threads any better than pure pthreads? Apart from portability concerns that is.
08:17:42 <elliott> Vorpal: Well, they have a bit more than just mutexes; run-once sections, conditions, and the aforementioned queues
08:17:48 <elliott> Maybe pthreads has queues, I dunno
08:17:50 <elliott> But portability is nice
08:18:02 <elliott> Oh, also read-write locks
08:18:04 <elliott> That's nice too
08:18:08 <Vorpal> elliott: I know pthreads have condition variables. No idea about run-once sections.
08:18:25 <elliott> Also ~RECURSIVE MUTEXES~
08:18:32 <Vorpal> pthreads have that
08:18:45 <Vorpal> also pthread_rwlock_init
08:18:56 <elliott> Deewiant: I'm wondering why I don't just make stopf situations drop the current packet
08:19:01 <elliott> Deewiant: The network protocol is synchronised at that point anyway
08:19:05 <kallisti_> Adjective:
08:19:07 <kallisti_> (of words or the person speaking them) Fluent and voluble but insincere and shallow.
08:19:15 <elliott> So... I'm gonna do that
08:19:22 <Vorpal> elliott: hm... won't that fuck up for the client?
08:19:35 <elliott> Vorpal: This happens after it's forwarded to the client
08:19:38 <Vorpal> ah okay
08:19:46 <elliott> The Notchian client just sort of magically makes sense of any data you throw at it
08:19:57 <Vorpal> elliott: might want to rename it from stopf to something else then
08:20:12 <Vorpal> elliott: really? I guess you should look at mcp stuff to figure out what you are missing then
08:20:15 <elliott> Vorpal: I'm not going to modify the macro to insert a return :-P
08:20:21 <elliott> And no, it mostly just ignores things
08:20:24 <Vorpal> heh
08:20:29 <elliott> I don't think we ever actually get these stopf errors these days
08:20:37 <elliott> But that's life, or some such
08:20:46 <Vorpal> bbl
08:20:51 <Vorpal> (university)
08:21:00 <elliott> More like unicrappity
08:21:31 <kallisti_> bbl
08:21:34 <kallisti_> (christmas carols)
08:21:59 <elliott> Deewiant: My delightful new prefix for these "zlib fucked up" errors is [WHAT]
08:29:06 <kallisti_> http://www.cracked.com/article_16508_6-terrifying-things-they-dont-tell-you-about-childbirth.html
08:29:11 <kallisti_> oh, I'm on this part of the internet again.
08:35:30 <zzo38> Is there any proper name for this? data T a b = T b ((T a b -> a) -> a); What is its meaning?
08:38:53 -!- Phantom_Hoover has joined.
08:39:31 <elliott> Deewiant: Can you please shoot whoever made gcc too stupid to realise that if (...) { x = y; } else if (...) { x = z; } else call_noreturn_function() cannot leave x uninitialised
08:40:02 <Phantom_Hoover> lambdabot!
08:40:03 <lambdabot> Phantom_Hoover: You have 8 new messages. '/msg lambdabot @messages' to read them.
08:41:04 <Deewiant> elliott: Ah, but what if somebody else provides a call_noreturn_function() that actually returns
08:41:17 <elliott> Deewiant: IT'S __ATTRIBUTE__((NORETURN))
08:41:18 <elliott> IN THE HEADER
08:41:33 <Deewiant> elliott: Do those __attribute__s actually have to match?
08:41:35 <Jafet> Shoot whoever made you use -Werror
08:41:36 <Deewiant> (I'm not sure)
08:41:57 * kallisti_ has just now watched double rainbow.
08:42:02 <elliott> Deewiant: I don't define it with that attribute in the .c file since it includes the relevant header :-P
08:42:10 <elliott> Jafet: fizzie
08:42:28 <elliott> Jafet: But I'm kinda warning-phobic anyway, it only takes about four warnings to make me start ignoring any fifth warning that might pop up
08:42:30 <Deewiant> elliott: But anyway, what if you explicitly return thereafter
08:42:32 -!- monqy has quit (Quit: hello).
08:42:57 <elliott> Deewiant: Doesn't work (thank god)
08:43:07 <elliott> I'm not sure what it's complaining about
08:43:14 <Jafet> Remember the zero-one-infinity rule. Fix all warnings, or fix the first warning, or ignore all warnings
08:43:15 <elliott> Is it just complaining because I declare them without initialising them RIGHT THERE...
08:43:31 <Jafet> C is easy anyway, you can initialize almost anything with 0
08:43:36 <Jafet> Be thankful you're not in C++
08:43:55 <elliott> http://sprunge.us/bGIN ;; COME ON LET ME APPLY THIS
08:44:03 <elliott> Jafet: Nope, socket_t must be used abstractly here
08:44:07 <elliott> Jafet: Could be a struct
08:44:17 <elliott> Jafet: On Windows it's a "SOCKET", whatever that is
08:44:40 <Jafet> A shout, for one thing
08:45:06 <elliott> Deewiant: BTW once I get around to pushing this stuff could you test the Windows build, I think it should even be working
08:46:21 <Deewiant> When I'm next in Windows after that, sure
09:05:00 * oerjan swats Sgeo for abbreviating Adjudicated Blind Collaborative Design Esolang Factory -----###
09:05:00 <lambdabot> oerjan: You have 3 new messages. '/msg lambdabot @messages' to read them.
09:05:57 <oerjan> :t ZipList
09:05:58 <lambdabot> forall a. [a] -> ZipList a
09:14:28 <oerjan> > scanl1 (zipWith (flip const)) [[1,2,3],[4,5],[6,7,8,9]]
09:14:30 <lambdabot> [[1,2,3],[4,5],[6,7]]
09:14:38 <oerjan> > scanl1 (zipWith (flip const)) []
09:14:40 <lambdabot> []
09:18:28 <zzo38> \setbox0=\hbox{\write16{\csname zzz\endcsname}}\show\zzz\shipout\box0\show\zzz
09:19:20 <elliott> oerjan: is that it?
09:19:23 <elliott> Deewiant: Language lawyer time
09:19:31 <elliott> Deewiant: Is it OK to define a function in a header and then never talk about it again and then link the program
09:19:33 <oerjan> no, just a small part
09:19:50 <Deewiant> elliott: Define, not declare?
09:19:54 <elliott> Er, declare
09:20:11 <Deewiant> Yes, of course
09:21:09 <elliott> Deewiant: Gross
09:21:12 -!- nooga has quit (Quit: Lost terminal).
09:21:34 <oerjan> > scanr1 ((drop 1 .) . (:)) [[1,2,3],[4,5],[6,7]]
09:21:35 <lambdabot> Occurs check: cannot construct the infinite type: a = [a]
09:21:40 <kallisti_> elliott: the alternative would be macro hacks.
09:21:41 <oerjan> oops
09:21:45 <Deewiant> elliott: math.h can be used without linking libm, you know :-P
09:22:09 <oerjan> > scanr1 ((. drop 1) . (:)) [[1,2,3],[4,5],[6,7]]
09:22:10 <elliott> Deewiant: BUT STILL
09:22:10 <lambdabot> Occurs check: cannot construct the infinite type: a = [a]
09:22:15 <oerjan> wtf
09:22:25 <oerjan> :t scanr1 ((. drop 1) . (:))
09:22:26 <lambdabot> Occurs check: cannot construct the infinite type: a = [a]
09:22:26 <lambdabot> Expected type: [a]
09:22:26 <lambdabot> Inferred type: [[a]]
09:22:29 <Deewiant> ?ty (. drop 1) . (:)
09:22:30 <lambdabot> forall a. a -> [a] -> [a]
09:22:35 <Deewiant> ?ty scanr1
09:22:36 <lambdabot> forall a. (a -> a -> a) -> [a] -> [a]
09:22:44 <oerjan> oh hm
09:23:00 <Deewiant> ?ty scanr
09:23:01 <lambdabot> forall a b. (a -> b -> b) -> b -> [a] -> [b]
09:23:06 <oerjan> > scanr ((. drop 1) . (:)) [] [[1,2,3],[4,5],[6,7]]
09:23:08 <lambdabot> [[[1,2,3]],[[4,5]],[[6,7]],[]]
09:23:20 <oerjan> > scanr ((drop 1 .) . (:)) [] [[1,2,3],[4,5],[6,7]]
09:23:22 <lambdabot> [[],[],[],[]]
09:23:30 <oerjan> oh hm
09:23:55 <Deewiant> > scanr1 ((. drop 1) . (++)) [[1,2,3],[4,5],[6,7]]
09:23:56 <lambdabot> [[1,2,3,5,7],[4,5,7],[6,7]]
09:24:03 <Deewiant> > scanr1 ((drop 1 .) . (++)) [[1,2,3],[4,5],[6,7]]
09:24:05 <lambdabot> [[2,3,5,6,7],[5,6,7],[6,7]]
09:24:19 * oerjan swats Deewiant for disturbing him
09:24:25 <oerjan> * -----###
09:24:36 <Deewiant> What're you trying to do :-P
09:24:46 <oerjan> ZipList join
09:25:40 <oerjan> :t (. ?f) . (:)
09:25:41 <lambdabot> forall (f :: * -> *) a. (?f::f [a], Functor f) => a -> f [a]
09:25:41 <zzo38> Once I made a join function for ZipList
09:26:19 <oerjan> :t (Prelude.. ?f) Prelude.. (:)
09:26:20 <lambdabot> forall a a1. (?f::a -> [a1]) => a1 -> a -> [a1]
09:26:41 <oerjan> argh
09:26:49 <oerjan> pointless is pointless today
09:27:13 <kallisti_> oerjan: complete double rainbow all the way.
09:27:21 <oerjan> :t scanr (\x xs -> x:map (drop 1) xs) [] [[1,2,3],[4,5],[6,7]]
09:27:22 <lambdabot> forall a. (Num a) => [[[a]]]
09:27:27 <oerjan> > scanr (\x xs -> x:map (drop 1) xs) [] [[1,2,3],[4,5],[6,7]]
09:27:27 <lambdabot> [[[1,2,3],[5],[]],[[4,5],[7]],[[6,7]],[]]
09:27:34 <oerjan> oops
09:27:39 <oerjan> > foldr (\x xs -> x:map (drop 1) xs) [] [[1,2,3],[4,5],[6,7]]
09:27:40 <lambdabot> [[1,2,3],[5],[]]
09:29:17 <oerjan> :t let join = ZipList . diag . scanl1 (zipWith (flip const)) . getZipList where diag = concat . takeWhile (not . null) . map (take 1) . foldr (\x xs -> x:map (drop 1) xs) [] in join
09:29:18 <lambdabot> forall a. ZipList [a] -> ZipList a
09:29:24 <oerjan> oops
09:29:41 <oerjan> :t let join = ZipList . diag . scanl1 (zipWith (flip const)) . map (getZipList) . getZipList where diag = concat . takeWhile (not . null) . map (take 1) . foldr (\x xs -> x:map (drop 1) xs) [] in join
09:29:42 <lambdabot> forall a. ZipList (ZipList a) -> ZipList a
09:30:03 <oerjan> @let zjoin = ZipList . diag . scanl1 (zipWith (flip const)) . map (getZipList) . getZipList where diag = concat . takeWhile (not . null) . map (take 1) . foldr (\x xs -> x:map (drop 1) xs) [] in zjoin
09:30:03 <lambdabot> Parse error: in
09:30:09 <oerjan> @let zjoin = ZipList . diag . scanl1 (zipWith (flip const)) . map (getZipList) . getZipList where diag = concat . takeWhile (not . null) . map (take 1) . foldr (\x xs -> x:map (drop 1) xs) []
09:30:10 <lambdabot> Defined.
09:30:17 <kallisti_> ze join
09:30:45 <oerjan> > getZipList . zjoin . ZipList . map ZipList $ [[1,2,3],[4,5],[6,7,8,9]]
09:30:47 <lambdabot> [1,5]
09:30:57 <oerjan> good, good
09:30:58 <elliott> oerjan: hm what are the monad laws stated with join...
09:30:59 <oerjan> elliott: ^
09:31:35 <oerjan> i have a cold so i'm not sure i can get all that
09:31:49 <Phantom_Hoover> Isn't join (return m) = m one of them?
09:32:00 <oerjan> i was just writing that.
09:32:03 <elliott> Phantom_Hoover: assuredly
09:32:27 <elliott> oerjan: and return (join m) = m, presumably?
09:32:43 <oerjan> no that doesn't look reversible
09:33:09 <oerjan> also join (return m) = m needs to be well typed
09:33:34 <elliott> join (fmap g (join (fmap f m))) = join (fmap (join . fmap g . f) m)
09:33:40 <elliott> is the long one
09:33:42 <elliott> translated directly
09:33:44 <elliott> it's uh
09:33:45 <elliott> quite ugly
09:33:46 <oerjan> some stuff like that
09:33:50 <elliott> hm well
09:33:53 <elliott> join x = join y
09:33:54 <elliott> can be reduced to
09:33:55 <elliott> x = y
09:33:56 <elliott> obviously
09:33:57 <oerjan> elliott: surely there must be some blog that has them
09:34:10 <elliott> fmap g (join (fmap f m)) = fmap (join . fmap g . f) m
09:34:14 <elliott> and surely we can lift that join outwards...
09:34:22 <elliott> oerjan: well ok
09:34:25 <oerjan> elliott: join is not a reversible operation, i said
09:34:37 <elliott> -- The standard monad laws.
09:34:37 <elliott> join . return == id
09:34:38 <elliott> join . fmap return == id
09:34:38 <elliott> join . join == join . fmap join
09:34:43 <elliott> those ones, apparently
09:34:52 <elliott> those seem... strangely short
09:34:57 <elliott> but i guess associativity is a detail of (>>=) itself
09:35:02 <Jafet> > join [[1]] == join [[],[1]]
09:35:03 <lambdabot> True
09:35:10 <oerjan> there are also the laws of fmap itself as a Functor, of course
09:35:19 <elliott> oerjan: yes but we know those are OK
09:35:22 <elliott> since we're only introducing Monad
09:35:34 <Jafet> fmap, like batman, has only one rule.
09:35:53 <oerjan> Jafet: two, actually
09:35:54 <elliott> @src ZipList return
09:35:54 <lambdabot> Source not found. That's something I cannot allow to happen.
09:35:58 <elliott> *grr*
09:36:29 <kallisti_> iiro[3[[3452#$[323523[62[45#${^347[2246}$%&4[646}#$%[34]3[4534[3[$)%%_3#
09:37:47 <oerjan> my brain was _just_ too fried to get \x xs -> x:map (drop 1) xs into point-free form, so the monad laws are obviously beyond reach.
09:37:49 <zzo38> I think the ZipList has similar to (Natural ->) monad (that is, assuming a type for any natural numbers!)
09:38:02 <zzo38> Except that ZipList can be finite
09:38:06 <elliott> oerjan: i'm working on proving these btw
09:38:47 <elliott> oerjan: hm would you call map getZipList (repeat m) = repeat (getZipList m) a distributive property
09:38:48 <Jafet> oerjan: foldr (.) id . map fmap == fmap . foldr (.) id
09:39:14 <oerjan> zzo38: yes, it's the finiteness that makes it complicated. in particular if the sublists are not sorted by length, monad laws break without the scanl1 (zipWith (flip const)) adjustment. i _hope_ that's enough.
09:39:42 <kallisti_> http://www.youtube.com/watch?v=f0P_btTkUgg
09:39:48 <oerjan> Jafet: the problem isn't me understanding it in general, it's understanding it when i have a cold
09:39:56 <kallisti_> that shit was off the chain wicked bananas.
09:40:00 <Jafet> Oh wait, my rule doesn't type in Haskell
09:40:34 <oerjan> you might want to include the actual function mapped over
09:41:01 <Jafet> I wanted to make it pointfree
09:41:18 <oerjan> Jafet: oh that's your formulation of the functor laws as one equation?
09:41:31 <elliott> > scanl1 f (repeat x)
09:41:32 <lambdabot> [x,f x x,f (f x x) x,f (f (f x x) x) x,f (f (f (f x x) x) x) x,f (f (f (f (...
09:41:48 <elliott> o-kay
09:42:02 <elliott> oerjan: proof of first law is currently at " ZipList . diag . scanl1 (zipWith (flip const)) . repeat $ getZipList m" btw
09:42:09 <elliott> which is
09:42:09 <zzo38> Do you know what this is? data T a b = T b ((T a b -> a) -> a); I don't know what this is?
09:42:10 <elliott> not very far :P
09:42:22 <Jafet> It's one law that says a functor is a group homeomorphism or something
09:42:35 <elliott> oerjan: btw what would you call \x xs -> x : map (drop 1) xs
09:42:36 <oerjan> elliott: you might want to understand join on a more intuitive level first?
09:42:40 <Jafet> Sadly in Haskell they must be written as two laws
09:42:51 <elliott> i put it in its own definition to keep my columns sane :P
09:42:56 <kallisti_> zzo38: cobarrier monads
09:43:05 <kallisti_> barrier comonads?
09:43:08 <kallisti_> cobarrier comonads?
09:43:08 <elliott> oerjan: ha! as if I could apply _intuition_ to a problem like this
09:43:42 <elliott> oerjan: isn't zipWith (flip const) = flip (zipWith const)
09:43:43 <kallisti_> oerjan: I understand join on an intuitive level. does that mean I can prove everything?
09:44:06 <elliott> > zipWith (flip const) x x
09:44:07 <lambdabot> Couldn't match expected type `[a]'
09:44:07 <lambdabot> against inferred type `SimpleRef...
09:44:13 <elliott> @check \xs -> zipWith (flip const) xs xs == xs
09:44:14 <lambdabot> "OK, passed 500 tests."
09:44:18 <kallisti_> elliott: hoo hoo hoo
09:44:22 <zzo38> kallisti_: Actually I don't know what it is.
09:44:58 <elliott> <elliott> oerjan: btw what would you call \x xs -> x : map (drop 1) xs
09:45:03 -!- augur has quit (Read error: Connection reset by peer).
09:45:12 <kallisti_> zzo38: it's a cobarrier monad..
09:45:12 <oerjan> elliott: the intuition is to take the diagonal of a matrix, but with the restriction that not just the diagonal elements but all elements above and to the left must also exist
09:45:25 <kallisti_> zzo38: (it's probabky not)
09:45:39 <oerjan> elliott: shear?
09:45:43 <elliott> oerjan: ok
09:46:01 <elliott> > foldr f z (repeat x)
09:46:02 <lambdabot> f x (f x (f x (f x (f x (f x (f x (f x (f x (f x (f x (f x (f x (f x (f x (...
09:46:35 <kallisti_> elliott: astonishing
09:46:42 <elliott> quite
09:46:50 <zzo38> kallisti_: I think it isn't, but I don't know. But I think it is a functor fmap f (T x y) = T (f x) $ \z -> y (z . fmap f);
09:46:56 <elliott> oerjan: now at the point ZipList . concat . takeWhile (not . null) . map (take 1) . fix . shear $ getZipList m :P
09:47:03 <oerjan> kallisti_: well you also have to understand _proofs_, i guess
09:47:17 <kallisti_> oerjan: sure I get proofs.
09:47:25 <oerjan> good, then there's hope.
09:47:31 <kallisti_> you start with X, you do shit until it's Y. QED
09:47:58 <elliott> ZipList . concat . takeWhile (not . null) . map (take 1) . fix $ \xs -> getZipList m : map (drop 1) xs
09:48:02 <oerjan> kallisti_: i assume you're being sarcastic
09:48:07 <elliott> oerjan: looks like we're getting somewhere
09:48:13 <kallisti_> oerjan: well that's one way to write proofs isn't it?
09:48:35 <oerjan> kallisti_: yes, but it's so vague it would apply to the work of most crackpots.
09:48:52 <kallisti_> of course it doesn't really describe proof by contradiction or induction very well.
09:49:33 <kallisti_> I bet there are proof techniques I've never even /heard/ of!!
09:49:44 <Jafet> Proof by crackpots
09:50:01 <elliott> oerjan: hm is map f $ fix (\xs -> x : map g xs) ==> fix (\xs -> f x : map g xs) valid
09:50:03 <elliott> i think so
09:50:20 <elliott> oh wait no
09:50:31 <zzo38> I am not very good at proofs in general but I could prove some things by myself, including Pythagorean theorem, and that the sequence of repeated run length encoding starting with 1 (1, 11, 21, 1211, 111221, etc) has only 1,2,3 and has no "333" in it
09:50:33 <elliott> map f $ fix (\xs -> x : map g xs) ==> fix (\xs -> f x : map (f . g) xs)
09:50:34 <elliott> is, though, I think
09:50:39 <elliott> (validate me oerjan? is this correct)
09:50:56 <oerjan> i have a cold, i say.
09:51:00 <elliott> > map f (fix (\xs -> x : map g xs)) :: [Expr]
09:51:01 <kallisti_> elliott: that doesn't look right to me.
09:51:01 <lambdabot> [f x,f (g x),f (g (g x)),f (g (g (g x))),f (g (g (g (g x)))),f (g (g (g (g ...
09:51:10 <elliott> > fix (\xs -> f x : map (f . g) xs) :: [Expr]
09:51:11 <lambdabot> Ambiguous type variable `a' in the constraints:
09:51:11 <lambdabot> `SimpleReflect.FromExpr ...
09:51:20 <kallisti_> elliott: oh wait
09:51:20 <elliott> > fix (\xs -> f x : map (\x -> f (g x)) xs) :: [Expr]
09:51:21 <kallisti_> nevermind
09:51:21 <lambdabot> Ambiguous type variable `t' in the constraints:
09:51:21 <lambdabot> `GHC.Show.Show t'
09:51:21 <lambdabot> a...
09:51:24 <elliott> argh!
09:51:29 <kallisti_> that looks right to me.
09:51:32 <kallisti_> I misreaed.
09:51:37 <elliott> kallisti_: shut up and let me get lambdabot to take it :)
09:51:50 <Jafet> > fix $ ([0,1]++) . map succ . concatMap ((:) <$> length <*> pure.head). group
09:51:51 <elliott> i think it is _not_ valid actually.
09:51:52 <lambdabot> [0,1,2,1,2,2,2,3,2,2,4,3,2,4,3,3,2,5,2,4,2,3,2,5,3,4,2,3,2,6,2,3,2,5,2,3,2,...
09:51:59 <elliott> :t fix (\xs -> f x : map (\x -> f (g x)) xs) :: [Expr]
09:52:00 <lambdabot> Ambiguous type variable `t' in the constraints:
09:52:00 <lambdabot> `Show t' arising from a use of `f' at <interactive>:1:29-35
09:52:00 <lambdabot> `SimpleReflect.FromExpr t'
09:52:00 <kallisti_> oh wait
09:52:01 <kallisti_> yeah
09:52:02 <kallisti_> nevermind
09:52:03 <elliott> :t fix (\xs -> f x : map (\x -> f (g x)) xs)
09:52:04 <lambdabot> forall a t. (SimpleReflect.FromExpr a, SimpleReflect.FromExpr (a -> t), SimpleReflect.FromExpr (t -> a)) => [a]
09:52:04 <kallisti_> it's not.
09:52:10 <elliott> sigh
09:53:09 <elliott> > let m = [1,2,3,4] in fix (\xs -> m : map (drop 1) xs)
09:53:09 <lambdabot> [[1,2,3,4],[2,3,4],[3,4],[4],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[...
09:53:13 <zzo38> Equatorial coordinates have right ascension and declination, or hour angle and declination, but is it sense to have local declination too?
09:53:18 <elliott> > inits [1,2,3,4]
09:53:19 <lambdabot> [[],[1],[1,2],[1,2,3],[1,2,3,4]]
09:53:23 <elliott> > tails [1,2,3,4]
09:53:24 <lambdabot> [[1,2,3,4],[2,3,4],[3,4],[4],[]]
09:53:27 <elliott> > tails [1,2,3,4] ++ repeat []
09:53:28 <lambdabot> [[1,2,3,4],[2,3,4],[3,4],[4],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[...
09:53:45 <kallisti_> elliott: with map f on the outside f only gets applied once to each element
09:53:49 <elliott> yes, I nkow
09:53:50 <elliott> know
09:53:56 <kallisti_> on the inside it gets applied... um, a lot.
09:53:59 <elliott> sh
09:54:00 <elliott> hh
09:54:36 <elliott> > map (take 1) (tails [1,2,3,4] ++ repeat [])
09:54:38 <lambdabot> [[1],[2],[3],[4],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[...
09:54:54 <elliott> > map pure [1,2,3,4] ++ repeat []
09:54:55 <lambdabot> [[1],[2],[3],[4],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[...
09:55:07 <kallisti_> > join . map $ (take 1) (tails [1,2,3,4] ++ repeat [])
09:55:08 <lambdabot> Couldn't match expected type `[a1] -> a'
09:55:08 <lambdabot> against inferred type `[a]'
09:55:18 <kallisti_> > join . map (take 1) $ (tails [1,2,3,4] ++ repeat [])
09:55:22 <lambdabot> mueval-core: Time limit exceeded
09:55:37 <kallisti_> can someone submit a bug report for me.
09:55:55 <kallisti_> titled "halting problem not solved"
09:56:03 <elliott> oerjan: ZipList . concat . takeWhile (not . null) $ map (:[]) (getZipList m)
09:56:12 <elliott> oerjan: looks like it's working
09:56:14 <Jafet> It is solved
09:56:20 <Jafet> See NonTerminationException
09:56:33 <oerjan> <elliott> (oerjan is sceptical that there are any Haskell ADTs that can be made applicative functors that can't be made monads (with the two instances agreeing))
09:56:36 <oerjan> i didn't say that.
09:56:41 <elliott> oerjan: i clarified later, but ok
09:57:32 <kallisti_> elliott: hmmm, I've run out of fractals. perhaps I need a new updoot theme?
09:57:42 <oerjan> kallisti_: CANTFIX
09:57:54 <elliott> oerjan: behold the most handwavey thing _ever_ written: http://sprunge.us/hfGR
09:58:02 <elliott> at least my steps are trivial enough to justify, I'm just too lazy to
09:58:16 <zzo38> Define a type of function, that if you have this function and pure and <*> then you can make join. Is there such a thing?
09:58:23 <elliott> zzo38: join
09:58:27 <elliott> it's called join.
09:58:56 <zzo38> I know that, but it isn't what I meant
09:59:26 <kallisti_> elliott: pick a theme for me
10:00:08 <kallisti_> hmm I'll try to find more fractals I guess.
10:00:12 <oerjan> elliott: pure m is what i call a "rectangular" element, so zjoin really cannot break on it - it essentially doesn't go outside the _Applicative_ part.
10:00:21 <elliott> oerjan: right
10:00:54 <elliott> oerjan: the join . fmap return one is going well: ZipList . diag . scanl1 (zipWith (flip const)) . map repeat $ getZipList m
10:01:12 <oerjan> that is, on a rectangular element, join is determined entirely by the Applicative functions.
10:01:20 <kallisti_> Sgeo: upoundary of the tame deetdragon
10:01:24 <oerjan> elliott: that one is also rectangular.
10:01:44 <elliott> oerjan: yes, I am sure that zjoin works fine in the theory you have used to create it :P
10:01:53 <oerjan> heh
10:02:15 <elliott> > scanl1 (zipWith (flip const)) $ map repeat [a,b,c]
10:02:17 <lambdabot> [[a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a...
10:02:19 <oerjan> elliott: for rectangular elements, the scanl1 (zipWith (flip const)) part does nothing.
10:02:22 <elliott> > tail . scanl1 (zipWith (flip const)) $ map repeat [a,b,c]
10:02:23 <lambdabot> [[b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b...
10:02:27 <elliott> right.
10:03:06 -!- Ngevd has joined.
10:03:11 <elliott> > foldr f z (map repeat [a,b,c,d])
10:03:12 <lambdabot> f [a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,...
10:03:20 <elliott> > foldr f z (map pure [a,b,c,d])
10:03:21 <lambdabot> No instance for (GHC.Show.Show (f SimpleReflect.Expr))
10:03:21 <lambdabot> arising from a us...
10:03:23 <Ngevd> Hello!
10:03:27 <elliott> > foldr f z (map (:[]) [a,b,c,d])
10:03:27 <lambdabot> f [a] (f [b] (f [c] (f [d] z)))
10:03:32 <elliott> ok not immensely surprising :P
10:04:05 <elliott> oh duh
10:04:11 <elliott> foldr f z . map g = foldr (f . g) z
10:04:12 <elliott> that'll help
10:04:30 <kallisti_> hahahaha broccoli has a measure Hausdorff dimension of 2.66
10:04:31 <kallisti_> awesome.
10:04:41 <kallisti_> *measured
10:06:19 <oerjan> that's also a measure dimension, sort of.
10:06:45 <oerjan> as it's the dimension of sets that may have nontrivial hausdorff measure of that degree
10:07:00 <oerjan> (degree may not be actual term)
10:07:51 <elliott> oerjan: join . fmap return = id proved
10:07:57 <elliott> join . join = join . fmap join -- this seems like the hard one
10:08:15 <kallisti_> elliott: oerjan: Norway is more Hausdorffy than Great Britain. Fight.
10:09:08 <oerjan> (apparently dimension is the term used)
10:09:26 <kallisti_> oerjan: indeed
10:09:31 <oerjan> kallisti_: why should i fight, it's obviously true
10:10:12 <oerjan> elliott: yeah that's the one where you have to test non-"rectangular" sets, so the scanl1 (zipWith (flip const)) part becomes important
10:10:21 <elliott> ZipList . diag . scanl1 (zipWith (flip const)) . map getZipList . diag . scanl1 (zipWith (flip const)) . map getZipList . getZipList $ m
10:10:22 <elliott> ZipList . diag . scanl1 (zipWith (flip const)) . map (getZipList . join) $ getZipList m
10:10:26 <elliott> oerjan: i have to prove these two lines equal
10:10:27 <kallisti_> oerjan: because you guys should take mathematics /personally/
10:10:28 <elliott> fml :P
10:10:36 <elliott> hmm
10:10:44 <elliott> ZipList . diag . scanl1 (zipWith (flip const)) . map getZipList . diag . scanl1 (zipWith (flip const)) . map getZipList . getZipList $ m
10:10:47 <elliott> ZipList . diag . scanl1 (zipWith (flip const)) . map getZipList . map join $ getZipList m
10:10:59 <elliott> so actually
10:11:00 <elliott> i just need to prove
10:11:01 <elliott> diag . scanl1 (zipWith (flip const)) . map getZipList
10:11:02 <elliott> = map join
10:11:04 <elliott> no?
10:11:13 <kallisti_> oerjan: also, maybe elliott secretly thinks having a lower Hausdorff dimensions is better for a high quality nation.
10:11:38 <oerjan> oh and on ZipLists "rectangular" elements obviously are what you intuitively call rectangles, it's just that it applies more generally to any attempt to extend Applicatives to Monads, i believe.
10:12:21 <elliott> oerjan: so what is it you actually believe about Applicative then
10:12:42 * kallisti_ believes Applicative created the world and made it flat.
10:13:04 <elliott> http://sprunge.us/XfUi; too lazy to do the last proof for now
10:13:06 <elliott> aka
10:13:09 <elliott> the one involving any kind of thought at all
10:13:31 <elliott> oerjan: have you checked whether this monad's ap and liftM agree?
10:14:44 <oerjan> that would be rather astounding, since they don't have the same type ;P
10:15:54 <oerjan> kallisti_: well lower hausdorff dimension probably gives easier industrial packaging.
10:16:00 <elliott> oerjan: har har har
10:16:03 <elliott> with the Applicative instance I mean of course
10:17:03 <Jafet> The Peano curve packs pretty well
10:17:03 <oerjan> elliott: well the zjoin is _designed_ to be correct on rectangular elements automatically, and all elements that are actually joined when constructing ap and liftM stuff are rectangular.
10:18:18 <elliott> oerjan: i meant tested empirically :P
10:18:26 <oerjan> probably not :P
10:19:48 <oerjan> fmap (\x -> fmap (f x) m) n is the general form of a rectangular element in an arbitrary Functor.
10:21:43 <elliott> Deewiant: I don't suppose you know how to get backtraces for individual threads in gdb after they all exit
10:21:43 <kallisti_> empiricism in math? zah1
10:21:45 <oerjan> applying join to that should give liftM2 f n m, so it's determined by the Applicative part.
10:22:00 <Deewiant> elliott: Nope, printf all the way
10:22:15 <elliott> Deewiant: :(
10:23:44 <oerjan> elliott: basically, you might want to prove zjoin (fmap (\x -> fmap (f x) m) n) = liftA2f n m as a lemma to use.
10:23:54 <oerjan> *liftA2 f n m
10:24:02 <elliott> oerjan: yes. when i get back to it :P
10:24:41 <oerjan> in a sense it is the initial definition of zjoin, which is then extended in some hopefully consistent way to all elements.
10:25:25 <oerjan> and from it should follow that everything Applicative behaves correctly with it.
10:27:30 <oerjan> and also the first and second monad laws. it's just the third one which can still break.
10:27:33 <oerjan> afair.
10:29:41 -!- Ngevd has quit (Ping timeout: 245 seconds).
10:31:26 <oerjan> elliott: btw my intuitive but maybe not sufficiently checked reason for why the scanl1 (zipWith (flip const)) adjustment should fix the join . join == join . fmap join third law formulation is that it forces the necessary _cubic_ parts of the m (m (m x)) element to exist.
10:31:34 <elliott> heh
10:31:43 <elliott> you should publish this >:)
10:32:30 <elliott> Functional Pearl: Categorical Gardening: Applicative Functors to Monads with Shears and Cubes
10:33:37 <oerjan> that is, an element is included in join (join m) iff its entire ancestor "cube" is included, which should be the same as the requirement for an element in join (fmap join m) to be included.
10:34:37 <kallisti_> elliott: Gregor has a paper called "The Eval that Men Do"
10:34:44 <kallisti_> which makes me cringe
10:34:47 <kallisti_> everytime I read it.
10:35:16 <oerjan> (the "cube" being the elements that are above and to the left of it in any of the containing sublists, seen as a 3-dimensional grid)
10:36:00 <elliott> kallisti_: we named that
10:36:28 <oerjan> elliott: that "shear" was a bit of a joke, it just looks like a geometric shear transformation in how it moves list elements.
10:37:04 <kallisti_> elliott: who's "we"?
10:37:36 <elliott> kallisti_: #esoteric
10:37:55 <oerjan> <kallisti_> elliott: Gregor has a paper called "The Eval that Men Do" <-- i recall that, i vaguely think he asked us for more eval suggestions :P
10:39:57 <Phantom_Hoover> The Root of All Eval is an obvious one.
10:40:11 <elliott> Phantom_Hoover: Yes, we covered all the bases.
10:40:16 <oerjan> i'm sure it was m... right
10:40:28 <Phantom_Hoover> Oh dear god this paper is amazing.
10:40:29 <oerjan> all your eval bases are belong to us
10:40:45 <kallisti_> "The Eval that Men Do" is better because it's still a horrible pun while also being relevant to the paper.
10:41:03 <kallisti_> whereas "The Root of All Eval" is less relevant
10:41:09 <oerjan> *-s
10:41:09 <kallisti_> unless you're talking about like.... trees or something.
10:50:52 -!- variable has quit (Excess Flood).
10:52:07 -!- variable has joined.
11:01:29 <elliott> "Encapsulate world queue into an abstract interface"
11:01:36 <elliott> Gotta think of a way to make this commit subject less terrible
11:05:37 <kallisti_> elliott: Inact the principle of information hiding on world queue by means of implementing an abstract protocol."
11:05:45 <kallisti_> s/^/"/
11:05:47 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
11:19:11 -!- Phantom_Hoover has joined.
11:28:00 -!- zzo38 has quit (Remote host closed the connection).
11:36:26 -!- oerjan has quit (Quit: leaving).
11:40:02 -!- sebbu2 has joined.
11:40:54 -!- sebbu has quit (Ping timeout: 244 seconds).
12:15:39 -!- elliott_ has joined.
12:15:39 -!- elliott has quit (Read error: Connection reset by peer).
12:32:28 -!- sebbu2 has quit (Ping timeout: 260 seconds).
12:35:00 -!- sebbu2 has joined.
12:35:00 -!- sebbu2 has quit (Changing host).
12:35:00 -!- sebbu2 has joined.
12:37:24 -!- Phantom_Hoover has left ("Leaving").
12:37:42 -!- Phantom_Hoover has joined.
12:39:26 -!- sebbu3 has joined.
12:41:35 -!- augur has joined.
12:43:23 -!- sebbu2 has quit (Ping timeout: 248 seconds).
12:53:27 -!- sebbu3 has changed nick to sebbu.
13:00:48 <itidus21> elliott_: you could try dumbing it down
13:01:55 <itidus21> "I maed an abstract interface out of teh world queue."
13:05:00 -!- Patashu has quit (Quit: MSN: Patashu@hotmail.com , Gmail: Patashu0@gmail.com , AIM: Patashu0 , YIM: patashu2 , Skype: patashu0 .).
13:16:12 -!- Ngevd has joined.
13:20:28 <Ngevd> Hello!
13:36:48 -!- sebbu2 has joined.
13:37:47 -!- sebbu has quit (Ping timeout: 248 seconds).
13:45:41 <kallisti_> > 2 + 2
13:45:42 <lambdabot> 4
13:47:24 <Ngevd> > tau
13:47:25 <lambdabot> Not in scope: `tau'
13:48:46 <Ngevd> > (0/0) == (0/0)
13:48:47 <lambdabot> False
13:52:24 <kallisti_> I think it's time
13:52:28 <kallisti_> for two monitors once again.
14:16:07 -!- elliott_ has quit (Read error: Connection reset by peer).
14:16:49 -!- elliott_ has joined.
14:18:17 <kallisti_> elliott_: hi
14:18:23 <elliott_> hi
14:25:59 <kallisti_> I wonder if Coke and coffee mixed together is good
14:29:44 <kallisti_> > pi :: Expr
14:29:45 <lambdabot> pi
14:29:50 <kallisti_> > deriv sin pi
14:29:51 <lambdabot> -1.0
14:29:57 <kallisti_> > deriv sin (pi :: Expr)
14:29:59 <lambdabot> 1 * cos pi
14:30:42 <kallisti_> elliott_: using Expr with deriv is actually very cool.
14:30:49 <elliott_> Yes, when it works :P
14:31:00 <kallisti_> what breaks, in particular?
14:32:00 <elliott_> I forget, sorry.
14:32:48 <kallisti_> elliott_: noooooo, how could you.
14:33:13 <kallisti_> I have abstracted you from "human being" to "limitless and impatient well of information"
14:33:25 <kallisti_> you're breaking my encapsulation!
14:36:47 <kallisti_> > deriv (\a -> a * sin a * ln a * a^2 + 1) (x :: Expr)
14:36:48 <lambdabot> Not in scope: `ln'
14:36:52 <kallisti_> > deriv (\a -> a * sin a * log a * a^2 + 1) (x :: Expr)
14:36:54 <lambdabot> ((1 * sin x + x * (1 * cos x)) * log x + x * sin x * (1 * recip x)) * (x * ...
14:37:42 <quintopia> why must it have 1 * everywhere?
14:37:46 <quintopia> what a waste!
14:38:22 <kallisti_> I guess Expr could special case 1 so that it's omitted, however, I think it's left in for demonstration of function implementations.
14:38:56 <kallisti_> it would be nice to have different Expr "styles", one that attempts to reduce expressions and one that's verbatim
14:40:47 <kallisti_> hmmm, also
14:41:23 <kallisti_> you could probably also extend Expr to generate ASTs?
14:44:03 <kallisti_> "I can (well, almost) hear you asking yourselves "why?". Hurd will be
14:44:03 <kallisti_> out in a year (or two, or next month, who knows), and I've already got
14:44:05 <kallisti_> minix."
14:44:19 <kallisti_> -- Linux Torvalds, 1991
14:44:25 <kallisti_> ...
14:44:27 <kallisti_> yes Linux
14:44:30 <kallisti_> I refuse to correct it.
14:46:23 <elliott_> <kallisti_> I guess Expr could special case 1 so that it's omitted, however, I think it's left in for demonstration of function implementations.
14:46:29 <elliott_> > reduce $ deriv sin (pi :: Expr)
14:46:30 <lambdabot> 1 * (-1.0)
14:46:35 <elliott_> heh
14:46:44 <elliott_> > exprValue $ deriv sin (pi :: Expr)
14:46:44 <lambdabot> Not in scope: `exprValue'
14:46:47 <kallisti_> oh interesting
14:47:18 <kallisti_> :t reduce
14:47:19 <lambdabot> Expr -> Expr
14:47:22 <kallisti_> @hoogle Expr -> a
14:47:23 <lambdabot> Warning: Unknown type Expr
14:47:23 <lambdabot> Unsafe.Coerce unsafeCoerce :: a -> b
14:47:23 <lambdabot> Prelude id :: a -> a
14:47:27 <kallisti_> bleh
14:47:29 <kallisti_> stupid hoogle
14:47:30 <elliott_> > intExpr $ deriv sin (pi :: Expr)
14:47:31 <lambdabot> Not in scope: `intExpr'
14:47:33 <elliott_> > doubleExpr $ deriv sin (pi :: Expr)
14:47:34 <lambdabot> Not in scope: `doubleExpr'
14:47:36 <elliott_> lame
14:48:09 <kallisti_> or wait, does Num make any assumptions about whether or not it's a field?
14:48:31 <kallisti_> :t fromIntegral
14:48:32 <lambdabot> forall a b. (Integral a, Num b) => a -> b
14:48:44 <kallisti_> in other words, is it required that fromIntegral 1 * x == x ?
14:49:28 <elliott_> Num has no laws
14:49:33 <kallisti_> oh, okay.
14:49:43 <elliott_> @quote without laws
14:49:44 <lambdabot> No quotes for this person. There are some things that I just don't know.
14:49:47 <elliott_> @quote elliott laws
14:49:48 <lambdabot> No quotes match. Take a stress pill and think things over.
14:49:50 <elliott_> @quote elliott_ laws
14:49:51 <lambdabot> No quotes for this person. Take a stress pill and think things over.
14:49:53 <elliott_> @quote elliott type
14:49:53 <lambdabot> elliott says: a typeclass is nothing without semantics
14:49:55 <kallisti_> @quote fuck
14:49:55 <elliott_> Oh.
14:49:56 <lambdabot> medfly says: <Ptival> THIS IS SPARTA! <medfly> go fuck yourself
14:50:00 <elliott_> I misremrembered myself'e'. :'(
14:50:16 <elliott_> Wow, Google just understood "ahaskel wekly naws".
14:50:49 <kallisti_> indeed it does.
14:51:09 <elliott_> http://www.google.co.uk/search?gcx=w&sourceid=chrome&ie=UTF-8&q=LEVENWEEJRIJSJW+DISTANCE
14:51:21 <kallisti_> alas
14:51:44 <kallisti_> LEVENstEW DISTANCE
14:51:45 <kallisti_> works
14:52:02 <elliott_> leven stew
14:52:41 <kallisti_> help sleep deprivation and weird blood pressure drops.
14:56:26 <kallisti_> elliott_: help me find ways to break deriv
14:56:41 <kallisti_> :t logBase
14:56:42 <lambdabot> forall a. (Floating a) => a -> a -> a
14:58:12 <kallisti_> elliott_: how is differentiation implemented in mathematica?
14:58:21 <elliott_> symbolically and badly
14:58:37 -!- copumpkin has joined.
14:58:49 <kallisti_> > deriv (\x -> fromEnum . isInfinity $ x) 3
14:58:50 <lambdabot> Not in scope: `isInfinity'
14:58:59 <kallisti_> > deriv (\x -> fromEnum . isNegativeZero $ x) 3
14:59:00 <lambdabot> Couldn't match expected type `Data.Number.Dif.Dif b'
14:59:01 <lambdabot> against inferr...
14:59:10 <kallisti_> > deriv (\x -> fromEnum . x == 2) 3
14:59:11 <lambdabot> Couldn't match expected type `Data.Number.Dif.Dif b'
14:59:12 <lambdabot> against inferr...
14:59:12 <kallisti_> lol
14:59:18 <kallisti_> > deriv (\x -> fromEnum (x == 2)) 3
14:59:19 <lambdabot> Couldn't match expected type `Data.Number.Dif.Dif b'
14:59:20 <lambdabot> against inferr...
14:59:22 <kallisti_> orjeiojwrrijweroijhweroihwetoihwer
14:59:26 <kallisti_> :t fromEnum
14:59:27 <lambdabot> forall a. (Enum a) => a -> Int
14:59:28 <kallisti_> oh
14:59:45 <kallisti_> > deriv (\x -> fromIntegral (fromEnum (x == 2))) 3
14:59:46 <lambdabot> 0
15:41:58 <Gregor> kallisti_: PUNPUNPUN
15:41:58 <lambdabot> Gregor: You have 1 new message. '/msg lambdabot @messages' to read it.
15:44:26 <kallisti_> Gregor: FUNFUNFUN
15:44:42 <kallisti_> > 1 `mappend` 2
15:44:43 <lambdabot> Ambiguous type variable `a' in the constraints:
15:44:43 <lambdabot> `Data.Monoid.Monoid a'
15:44:43 <lambdabot> ...
15:44:59 <kallisti_> :t Add
15:45:00 <lambdabot> Not in scope: data constructor `Add'
15:45:38 <kallisti_> > Sum 1 `mappend` Sum 2
15:45:39 <lambdabot> Sum {getSum = 3}
15:45:46 <kallisti_> amazing.
15:47:24 -!- copumpkin has quit (Remote host closed the connection).
15:47:42 <kallisti_> > const (Sum 3) `mappend` const (Sum 4) $ 6
15:47:44 <lambdabot> Sum {getSum = 7}
15:47:48 -!- copumpkin has joined.
15:48:46 <kallisti_> > tail `mappend` (++"dongs") $ " lol"
15:48:48 <lambdabot> "lol loldongs"
15:50:14 <kallisti_> sometimes I feel the number of instances you can make with a -> b is just out of hand.
15:50:38 <kallisti_> most of the time, however
15:50:41 <kallisti_> I don't think that.
16:00:11 -!- kallisti_ has quit (Ping timeout: 252 seconds).
16:05:33 -!- kallisti has joined.
16:05:33 -!- kallisti has quit (Changing host).
16:05:34 -!- kallisti has joined.
16:12:14 -!- ais523 has joined.
16:13:09 <ais523> well, I completed Braid, anyway (any%; 100%ing it takes years without spoilers, apparently, and the game disguises the fact that there is a better ending than the obvious one)
16:20:19 <elliott_> ais523: apparently you have to wait on one level for like two hours or some other dumb shit like that
16:21:12 <ais523> yep
16:21:19 <ais523> around an hour and a half
16:21:30 <elliott_> why did he think that was a good idea
16:23:14 <ais523> well, the mere existence of the stars is hidden
16:23:18 <elliott_> incidentally, does anyone know a better way of deleting a function definition in vim than d/^}/?
16:23:32 <ais523> and putting things behind very long waits is a good way to hide them
16:23:37 <elliott_> ddd% works, but is gross
16:23:44 <ais523> (it's how most of the instances of Totaka's Song are hidden, for instance)
16:24:20 <elliott_> oh, d]} might do it
16:24:32 <elliott_> oh! d}
16:24:37 <elliott_> nice
16:26:40 <ais523> the other issue with Braid is that you don't get to hear the music much
16:26:49 <ais523> as half the time it's playing backwards or at a crazy speed or whatever
16:27:59 <ais523> hmm, fun thing I just noticed by accident: the MediaWiki keyboard shortcut for "delete" (alt-shift-d) means "undelete" on a nonexistent page
16:29:30 <elliott_> (diff) (hist) . . m Excela‎; 12:24 . . (+1,570) . . Oerjan (Talk | contribs) (Fnord)
16:29:30 <elliott_> (diff) (hist) . . Excela‎; 10:35 . . (-1,570) . . Theodorex1Jf (Talk | contribs)
16:29:35 <elliott_> ais523: _please_ protect Excela already...
16:29:42 <elliott_> oh wait
16:29:47 <elliott_> you said they moved to another page if they did that
16:29:49 <ais523> yep
16:29:52 <elliott_> have we had google translate bots before?
16:29:57 <elliott_> I don't recall any but I may be wrong
16:30:06 <ais523> I don't think so
16:30:14 <elliott_> ais523: just protect every page except [[Snack]] for a few days
16:30:17 <ais523> but it may be the same framework finding anew way to get around filters
16:30:19 <elliott_> then we don't have to bother reverting
16:30:34 <ais523> also, protecting an entire namespace needs dev powers
16:30:43 <elliott_> I meant manually :)
16:30:44 <ais523> or a huge amount of very very spammy protection by hand
16:31:03 <elliott_> ais523: ooh, now I want to not revert the spam for long enough to see if the bots will ever re-mangle a mangled page
16:31:21 <elliott_> maybe if left to their own devices they'll turn any page into completely unintelligible mush
16:31:26 <elliott_> s/maybe if/maybe/
16:33:11 -!- aloril has quit (Ping timeout: 252 seconds).
16:34:41 -!- Ngevd has quit (Ping timeout: 245 seconds).
16:38:08 -!- Ngevd has joined.
16:38:27 -!- Ngevd has quit (Client Quit).
16:41:14 <Vorpal> <ais523> as half the time it's playing backwards or at a crazy speed or whatever <-- that annoyed me too
16:41:25 <Vorpal> anyway how did you end up playing Braid?
16:41:57 <Vorpal> <elliott_> ais523: apparently you have to wait on one level for like two hours or some other dumb shit like that <-- just let it run in the background while you eat lunch
16:42:28 <ais523> Vorpal: I watched a speedrun, and it inspired me to play the game
16:42:32 <Vorpal> heh
16:42:39 <ais523> I had it already, but it had a dependency on nvidia-something so I thought it wouldn't work
16:42:42 <Vorpal> ah
16:42:46 <ais523> but I installed the nvidia package anyway and it did work
16:42:54 <Vorpal> hm
16:43:04 <Vorpal> ais523: I played it on ati/amd so yeah
16:43:32 <ais523> I use Intel graphics; I deliberately aim for laptops which have them
16:43:43 <ais523> works better on Linux than the alternatives, typically
16:43:49 <Vorpal> hybrid graphics is a nice alternative there
16:43:56 <elliott_> ais523: Better modulo their being terrible
16:44:02 <elliott_> Good drivers only get you so far :P
16:44:03 <Vorpal> you can use intel unless you want good 3D performance
16:44:04 <ais523> elliott_: they're good /enough/
16:44:07 <ais523> for what I want to do
16:44:22 <ais523> what's important for me are good drivers and good enough 3D performance
16:44:25 <ais523> and Intel hits both requirements
16:44:50 <Vorpal> you have very low 3D expectations then
16:45:54 <ais523> it's good enough to play Neverwinter Nights
16:46:00 <ais523> which admittedly is a pretty old game
16:46:12 -!- aloril has joined.
16:46:46 <Vorpal> ais523: come on, I had some third-party stuff fail on intel graphics in NWN due to texture compression formats that weren't supported
16:46:56 <Vorpal> and you can't really drag the graphical quality settings to max
16:47:10 <Vorpal> which is ridiculous for such an old game.
16:47:35 <Vorpal> anything that isn't intel graphics have been able to run nwn on max graphical settings for several years
16:47:57 <itidus21> so OSX is estimated at 86,000,000 lines of code.. windows xp at 45,000,000 lines of code.. do you think a haskell OS would end up down at 1,000,000?
16:49:07 <Vorpal> os x is larger than windows xp?
16:49:08 <Vorpal> heh
16:49:11 <Vorpal> which version of os x
16:49:23 <itidus21> i said estimated anyway
16:49:26 <Vorpal> ah okay
16:49:29 <itidus21> 10.4
16:49:46 <itidus21> wiki reference says
16:49:50 <itidus21> "Jobs, Steve (August 2006). "Live from WWDC 2006: Steve Jobs Keynote". Retrieved 2007-02-16. "86 million lines of source code that was ported to run on an entirely new architecture with zero hiccups.""
16:52:40 <itidus21> Windows XP, released in 2001, has 35 million lines of code
16:52:57 <itidus21> . Windows XP was compiled of 45 million lines of code.
16:53:16 <itidus21> whats 10 million lines of code between friends
16:55:15 <itidus21> Several thousand engineers have labored to build and test Windows Vista, a sprawling, complex software construction project with 50 million lines of code, or more than 40 percent larger than Windows XP.
16:55:43 <itidus21> clearly theres a bit of bullshitting going on somewhere
16:56:59 <itidus21> the new york times says "35 million lines of code."
16:57:10 <itidus21> wiki sourcing the windows facebook page says 45
16:57:33 <itidus21> seems these numbers are fairly meaningless
16:58:04 <itidus21> jeff atwood says 40 million
16:58:30 <itidus21> apparently quoting wikipedia
17:12:07 -!- copumpkin has quit (Remote host closed the connection).
17:17:45 -!- copumpkin has joined.
17:25:14 -!- monqy has joined.
17:25:45 <kallisti> in 2008 Linux had approx. 6 million lines of actual code.
17:25:56 <kallisti> over 10 million includes whitespace and comments.
17:26:52 <kallisti> note this is just the kernel itself.
17:29:36 <kallisti> 9793 Torvalds, an asteroid named after Linus Torvalds
17:29:36 <kallisti> 9882 Stallman, an asteroid named after Richard Matthew Stallman, American hacker, founder of the free software movement and the GNU project
17:29:39 <kallisti> 9965 GNU, an asteroid named after the GNU project
17:29:53 <kallisti> 9885 Linux is an asteroid discovered on October 12, 1994 by Spacewatch. The asteroid is named after the Linux operating system kernel
17:30:18 <kallisti> I love asteroid names.
17:31:59 <kallisti> wow there are 18,269 Main Belt asteroid articles.
17:33:27 <elliott_> probably mostly autogenerated
17:33:38 <elliott_> kallisti: 1994?
17:33:46 <elliott_> named after Linux only 3 years after it began...
17:34:00 <Deewiant> Discovered
17:34:06 <Deewiant> Named, possibly later
17:34:14 <elliott_> Ah
17:34:28 <Deewiant> Or not, but I think that's possible
17:35:04 <elliott_> I suppose Linux would have been fairly popular in that kind of environment by 1994
17:36:01 <Deewiant> 14070060 total lines in Linux 3.1.1, according to ohcount; 10011948 excluding comments and whitespace
17:36:30 <elliott_> Deewiant: How much excluding drivers?
17:36:40 <Deewiant> (This includes xml, xslt, scheme, and other languages)
17:36:51 <elliott_> I bet a lot of that is documentation
17:37:00 <elliott_> Probably not *that* much though :P
17:37:16 <kallisti> As of January 4, 2011, using current LOC and wage numbers with David A. Wheeler's calculations it would cost approximately 3 billion USD (about 2.2 billion EUR) to redevelop the Linux kernel.
17:37:24 <Deewiant> If you want just the C and assembler files, 13233055+459402 and 9396007+362268
17:37:38 <elliott_> kallisti: David A. Wheeler's calculations = sloccount's bullshit estimates :P
17:37:50 <elliott_> Ohloh and sloccount and all these things always estimate like a million times what things would actually cost to develop
17:37:53 <Deewiant> There's also 247515+149638 of "cpp", which I guess is headers
17:38:01 <elliott_> I think they claimed cfunge would cost like $80k or something
17:38:20 <elliott_> Deewiant: I'm more interested in how much of that is driver code
17:38:39 <Deewiant> elliott_: I'm running your not-drivers calculation, it'll take a while
17:38:41 <kallisti> elliott_: hey programmers are expensive. and lazy.
17:38:47 <elliott_> Adding a driver doesn't really increase the overall complexity of a system, so in some sense drivers are free from the perspective of the rest of the system
17:39:00 <elliott_> Whereas adding code within the core system does increase complexity
17:42:13 <Deewiant> elliott_: http://sprunge.us/TXcC
17:42:50 <elliott_> Wow, so only 56% of Linux is drivers
17:43:01 <elliott_> That's an awfully big core
17:44:11 <kallisti> elliott_: so assuming an average yearly salary of $63k (current average in the US), they're saying it would take....
17:44:44 <kallisti> > (63/80)*12
17:44:46 <lambdabot> 9.45
17:44:55 <kallisti> one person 9.45 months to code cfunge?
17:45:30 <kallisti> (granted they probably used a different estimation technique)
17:45:39 <kallisti> (or at least a different average salary)
17:46:03 <elliott_> kallisti: I believe the method is literally "take statistic for lines/day a programmer writes, scale by salary"
17:46:26 <elliott_> http://hg.openjdk.java.net/hsx/hotspot-rt/hotspot/rev/763f01599ff4 Ha ha ha oh boy
17:46:59 <kallisti> oh, well that's kind of reasonable I guess.
17:48:50 <kallisti> assuming it's non-whitespace lines.
17:49:04 <kallisti> well...
17:49:13 <kallisti> no I guess those kind of count too? comments do anyway
17:49:29 <kallisti> as that represents documentation effort.
17:53:45 <elliott_> "Of course 5 years from now that will be different, but 5 years from now everyone will be running free GNU on their 200 MIPS, 64M SPARCstation-5."
17:53:52 <elliott_> linus v. tanenbaum is so fun
17:54:05 <elliott_> it's like they're pretending to be oblivious people in 1992
17:54:09 <elliott_> badly
17:54:53 -!- oerjan has joined.
17:54:53 * kallisti is like he's pretending to be an oblivious person in 2011
17:55:59 <kallisti> interestingly enough it takes about as much time for a person to produce cfunge as it does to create a baby.
17:56:06 <kallisti> based on that probably horrible estimate.
17:56:24 -!- Ngevd has joined.
17:56:26 <Ngevd> Hello!
17:57:02 <oerjan> hi
17:57:52 <oerjan> next: produce a funge98 interpreter through genetically engineering a baby
17:58:39 <kallisti> !hey
17:58:39 <kallisti> it would be horrible if compilers attempted to detect typos and simply corrected them under the hood...
17:58:58 <Ngevd> I've heard of a compiler that did that
17:59:05 <Ngevd> Apparently it was awful
17:59:31 <Ngevd> <kallisti> interestingly enough it takes about as much time for a person to produce cfunge as it does to create a baby. <-- it takes 2 people to create a baby
17:59:34 <oerjan> well perl supposedly resolves ambiguities automatically
17:59:48 <Vorpal> ais523: I just saw an interesting way to upload a *.patch to a mediawiki installation that didn't accept that type: "File:Makefile.patch.png"
18:00:11 <Vorpal> ais523: do people ever try that sort of stuff on wikipedia?
18:00:13 <elliott_> Vorpal: just write a piet program that performs the patch
18:00:22 <elliott_> nobody can delete that for not being a valid image
18:00:23 <Vorpal> hah
18:00:28 <Gregor> `addquote <kallisti> interestingly enough it takes about as much time for a person to produce cfunge as it does to create a baby.
18:00:34 <Vorpal> elliott_: it is on the defcon dev wiki
18:00:37 <HackEgo> 741) <kallisti> interestingly enough it takes about as much time for a person to produce cfunge as it does to create a baby.
18:00:47 <ais523> Vorpal: people attempted it occasionally; on Wikipeida such files can be speedied
18:00:49 <ais523> *Wikipedia
18:00:50 <Vorpal> ah
18:00:56 -!- derrik has joined.
18:01:33 <Vorpal> elliott_: you know you get dev access to uplink/darwinia/defcon/multiwinia with the humble bundle now
18:01:36 <Vorpal> which is great
18:01:51 <elliott_> No, I completely missed getting an email about it and it being near the top of /r/programming.
18:01:56 <Vorpal> I think normally they sell that for a higher price
18:02:03 <elliott_> See, what I usually do is ignore my email and not read reddit, because hey, Vorpal will let me know.
18:02:06 <Vorpal> elliott_: ah good thing I told you then :P
18:02:16 <ais523> happy australian mailman mailing list reminders day!
18:02:22 <elliott_> Vorpal: DEFCON and Multiwinia source are new, I believe.
18:02:27 <Vorpal> hm really
18:02:29 <Vorpal> okay
18:02:33 <elliott_> No, just DEFCON.
18:02:35 <ais523> elliott_: it's even on Slashdot
18:02:37 <Vorpal> elliott_: anyway my statement was correct then. I forgot the question mark above
18:02:37 <Gregor> ais523: It's the most - wonderful tiiiiime of the year!
18:02:47 <Vorpal> so yes you knew it. Which was all I stated :P
18:02:53 <elliott_> ais523: happy ammlr day!
18:03:00 <elliott_> hmm, abbreviation ruins it
18:03:09 <ais523> yep, you have to write it out
18:03:14 <Vorpal> speaking of which. Tomorrow is my birthday
18:03:25 <elliott_> ais523: happy australian mailman mailing list reminders day, then
18:03:39 <elliott_> Vorpal: sorry, I only wish people happies on australian mailman mailing list reminders day.
18:03:42 <Ngevd> Vorpal, how old will that make you?
18:03:47 <oerjan> the day we worship the ancient sumerian god Amm Lr
18:03:52 <elliott_> Vorpal: try getting a better birthday
18:04:05 <elliott_> ais523: haha, I just noticed how many players blognomic has now
18:04:06 <Vorpal> Ngevd: err, I'm old enough to not think much about my age. Lets see... *gets calculator*
18:04:23 <oerjan> Vorpal is old as dirt
18:04:24 <Vorpal> 22
18:04:24 <ais523> elliott_: it's going back to normal
18:04:39 <elliott_> oerjan: have you had a birthday recently, i kinda lose track
18:04:44 <Vorpal> oerjan: but seriously, you stop thinking about exact age once you get past 20 or so.
18:04:48 <ais523> wow, I'm older than Vorpal?
18:04:56 <elliott_> of course you are
18:04:57 <Vorpal> ais523: aren't you like 24?
18:05:00 <ais523> yes
18:05:14 <elliott_> does ais523 not remember when Vorpal was 18
18:05:17 <Vorpal> anyway of course, I thought it was well established
18:05:19 <elliott_> or was it 19
18:05:28 <oerjan> elliott_: if by "recently" you mean in the last 6 months, then yes.
18:05:32 <Vorpal> elliott_: err I was in this channel before I turned 18 I'm pretty sure
18:05:43 <elliott_> Vorpal: no
18:05:46 <elliott_> oerjan: happy belated australian mailman mailing list reminders day!
18:05:49 <Vorpal> elliott_: yes.
18:05:53 <elliott_> Vorpal: 2008
18:05:59 <oerjan> Vorpal: only until you start reaching round numbers again :P
18:06:07 <Vorpal> hm
18:06:12 <Vorpal> oerjan: :/
18:06:15 <elliott_> oh, hmm, 2007
18:06:21 <elliott_> Vorpal: 2007-10-30
18:06:27 <Vorpal> elliott_: so 17 then
18:06:31 <elliott_> is the day I made my worst mistake
18:06:35 <Vorpal> lol
18:06:35 <Ngevd> elliott_, how old were you when you came here?
18:06:46 <Vorpal> 11 or 12 iirc?
18:06:48 <elliott_> Ngevd: umm, 11 or 12
18:06:50 <elliott_> I forget exactly
18:07:12 <Ngevd> When I was 11 or 12, that was about when I started in the Murderous Maths forum
18:07:13 <Ngevd> I think
18:07:20 <Ngevd> Which I have since sadly abandoned
18:08:05 <oerjan> Ngevd: well it's good you left before you were murdered
18:08:07 <Vorpal> arvid=> select * from irc.logs_na where nick = 'elliott' order by serial ASC limit 1;
18:08:07 <Vorpal> serial | tstamp | nick | target | uhost | type | body
18:08:07 <Vorpal> --------+---------------------+---------+--------+--------------------------------------------+------+------
18:08:07 <Vorpal> 208001 | 2006-12-29 21:42:41 | elliott | | n=ehird@user-5440e204.wfd80a.dsl.pol.co.uk | 3 |
18:08:12 <Vorpal> elliott_: you can count it from that
18:08:17 <Ngevd> Yep, I was 12
18:08:29 <Ngevd> The 16th of October 2007
18:08:29 <Vorpal> (note, normalised nick, that is why it says elliott)
18:08:32 <elliott_> Vorpal: that one doesn't count, i joined, was too intimidated to say anything, then left
18:08:37 <elliott_> the next time i joined was in 2007
18:08:44 <Vorpal> elliott_: wait is it normalised or normalized in UK English?
18:08:55 <elliott_> Vorpal: depends on dialect
18:08:58 <Ngevd> Depends whether en-gb or en-gb-OED
18:08:59 <elliott_> OED uses -zed
18:09:13 <elliott_> Ngevd: *en-GB, *en-GB-oed
18:09:14 <Vorpal> 208001 | 2006-12-29 21:42:41 | elliott | | n=ehird@user-5440e204.wfd80a.dsl.pol.co.uk | 3 |
18:09:14 <Vorpal> 208002 | 2006-12-29 21:43:09 | elliott | | | 4 |
18:09:14 <Vorpal> 271393 | 2007-05-14 17:48:38 | elliott | | n=ehird@user-54457988.lns6-c11.dsl.pol.co.uk | 3 |
18:09:22 <Vorpal> elliott_: too intimidated by what?
18:09:25 <Ngevd> I joined the UMMF 17 days before my 13th birthday
18:09:30 <elliott_> Vorpal: lots of people and silence!!!!
18:09:34 <Vorpal> elliott_: heh
18:09:45 <elliott_> you could have all been nasty. I don't talk until I'm sure I'm the nastiest one present
18:09:56 <Vorpal> hah
18:10:18 <elliott_> anyway 11 then, assuming i can do arithmetic
18:10:22 <oerjan> wait OED isn't the default for en-gb? sacrilege!
18:10:23 <elliott_> which i'm not sure of
18:10:30 <elliott_> 1995-08 --> 2006-12
18:10:36 <elliott_> or --> 2007-05, the same either way
18:10:55 <elliott_> oerjan: -zed is the only common case where -oed disagrees from common british english usage iirc
18:11:03 <oerjan> aha
18:11:26 <elliott_> oerjan: and they list -ise too
18:11:29 <elliott_> just not as the preferred spelling
18:11:36 <elliott_> "The use of -ize instead of -ise does not affect the spelling of words ending in -yse, such as analyse, paralyse and catalyse"
18:11:38 <elliott_> didn't know that
18:12:11 <oerjan> an excellent analyzis
18:14:12 <elliott_> oerjan: oh, looks like OED has a few other idiosyncrasies too, like preferring "co-operate"
18:14:29 <oerjan> coöperäte
18:14:33 <elliott_> oerjan: confusing matters further, it seems like "cooperate" is what appears in their "consumer" dictionaries
18:14:42 <elliott_> as opposed to the unusable-as-a-dictionary OED text itself :P
18:14:44 <Gregor> As opposed to English cooperate, or Esoterian coperate.
18:15:11 <elliott_> Read as "Estonian".
18:15:12 <oerjan> or volapük köüperät
18:15:23 <elliott_> Was confusing, 'cuz they do use os and diaereses a lot.
18:15:24 <oerjan> (note: possibly not actual volapük)
18:15:57 <elliott_> lojban c'ou,. zrxrope
18:16:20 <oerjan> c'ou,. tvtrope
18:16:29 -!- Slereah_ has joined.
18:16:59 <elliott_> http://oxforddictionaries.com/definition/cooperate?view=uk or is it.....
18:17:06 <elliott_> i don't care enough to try and dig deeper
18:17:22 <Phantom_Hoover> Coöperate.
18:17:28 <oerjan> cöpærüt
18:17:35 <Ngevd> http://en.wiktionary.org/wiki/cooperate#Alternative_forms
18:17:47 <elliott_> oerjan: pretty
18:17:47 -!- Slereah has quit (Ping timeout: 248 seconds).
18:17:54 <elliott_> Phantom_Hoover: <Gregor> As opposed to English cooperate, or Esoterian coöperate.
18:18:05 <elliott_> Phantom_Hoover: Anyway I will stop being annoyed by your diaeresing if you apply it properly.
18:18:07 <Phantom_Hoover> Ah, of course.
18:18:18 <Phantom_Hoover> elliott_, excuse me how else do you apply it.
18:18:23 <elliott_> Phantom_Hoover: I.e., to all diaereses, not just diaereses on adjacent vowels.
18:18:35 <elliott_> I once talked like that for an /entire minute/; I'm sure you can manage.
18:18:42 <Phantom_Hoover> Yes fine I will do it.
18:18:42 <elliott_> Erm
18:18:46 <elliott_> s/adjacent vowels/repeated vowels/
18:19:59 <Phantom_Hoover> This is quite easy.
18:20:15 <Phantom_Hoover> ('ea' isn't a diaeresis.)
18:20:20 <Phantom_Hoover> (Nor is that one.)
18:20:37 <elliott_> Phantom_Hoover: Talk about poetry.
18:20:46 <Phantom_Hoover> *poëtry.
18:21:14 <elliott_> Phantom_Hoover: Also shouldn't it be di(ae with " on top)resis because of the i, or am I wrong.
18:21:23 <elliott_> In phonology, hiatus (English: /haɪˈeɪtəs/; Latin: [hɪˈaːtʊs] "gaping")[1] or diaeresis (/daɪˈɛrɨsɨs/ or /daɪˈɪərɨsɨs/,[2] from Ancient Greek διαίρεσις diaíresis "division")[3] refers to two vowel sounds occurring in adjacent syllables, with no intervening consonant. When two adjacent vowel sounds occur in the same syllable, the result is instead described as a diphthong.
18:21:23 <elliott_> The English words hiatus and diaeresis themselves contain a hiatus between the first and second syllables.
18:21:59 <elliott_> Yeah, you need "diæ̈resis".
18:22:13 <Phantom_Hoover> How far does this rabbit hole go?
18:22:31 <elliott_> SO FAR.
18:22:37 <Ngevd> I would have gone for potry
18:22:48 <elliott_> Phantom_Hoover: Will you cooperate on your hiatus to produce poetry with diaereses?
18:22:50 <Phantom_Hoover> Yes, that is because you are an idiöt.
18:23:13 <oerjan> 16:29:35: <elliott_> ais523: _please_ protect Excela already...
18:23:14 <oerjan> 16:29:42: <elliott_> oh wait
18:23:14 <oerjan> 16:29:47: <elliott_> you said they moved to another page if they did that
18:23:31 <oerjan> what we need is some way to protect the page so the bots don't actually realize it is protected
18:23:33 <Phantom_Hoover> is excela a brainfuck derivative
18:23:41 <elliott_> oerjan: ghostprotecting?
18:23:54 <oerjan> ...i guess
18:24:01 <Phantom_Hoover> Ghostecting.
18:24:07 <elliott_> oerjan: ("ghostbanning" is a common term for the forum equivalent of that)
18:24:13 <elliott_> (only the ghostbanned user can see their own posts)
18:24:28 <oerjan> elliott_: well it sounds like what reddit does with voting
18:24:28 <elliott_> that would require an extension that probably doesn't even _exist_ yet though, so good luck with that :P
18:24:37 <elliott_> oerjan: yeah
18:24:53 <Phantom_Hoover> Wow, diȧėreses (look, I don't have a compose binding for it) are remarkably uncommon.
18:25:11 <elliott_> Phantom_Hoover: æ̈ here you go.
18:25:24 -!- elliott_ has left ("Leaving").
18:25:26 -!- elliott_ has joined.
18:25:27 <Phantom_Hoover> elliott_, better, get me a decent .XCompose.
18:25:38 <elliott_> Phantom_Hoover: I think if you get an ae, and then do what you do for a diaeresis and then press space, it'll work.
18:26:07 <Phantom_Hoover> Nope.
18:26:32 <elliott_> *shruggot*
18:26:33 <oerjan> elliott_: it's rather ridiculous with a page that has a plethora of recent edits but hasn't really been changed since 2006 :P
18:26:36 <elliott_> I wish I knew of a decent .XCompose.
18:26:48 <elliott_> oerjan: we should start improving it to confuse the spambots
18:26:52 <oerjan> heh
18:27:19 <oerjan> die, reses!
18:27:29 <Phantom_Hoover> elliött_, I distinctly recall someöne linking me to one on reddit, but I didn't keep track of it.
18:28:44 <Phantom_Hoover> http://forums.introversion.co.uk/introversion/viewtopic.php?t=3003
18:28:49 <Phantom_Hoover> *snigger*
18:30:19 <elliott_> Phantom_Hoover: hehehehehe
18:30:21 <elliott_> headclot
18:30:46 <elliott_> "Who said I was joking - I bought the Humble Introversion bundle and I was quite impressed at what I saw."
18:30:52 <oerjan> <kallisti> 9882 Stallman, an asteroid named after Richard Matthew Stallman, American hacker, founder of the free software movement and the GNU project
18:30:53 <elliott_> Email: Technology_rocks@hotmail.com
18:31:02 <oerjan> if that ever gets close to earth, we're fucked
18:31:52 <elliott_> "We do not exist on the internet yet at least. :/"
18:31:54 <oerjan> Humble INTP bundle
18:31:55 <elliott_> heheheheehehehehehehe
18:32:42 <oerjan> hm i haven't seen myers-briggs mentioned much in a while
18:46:03 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
18:47:58 <elliott_> oerjan: where?
18:48:44 <oerjan> elliott_: um, i didn't mean to imply that i'd seen it, i just thought of the fact i hadn't after making that pun
18:49:12 <elliott_> ok
18:49:34 -!- derrik has quit (Quit: restart).
18:52:40 <oerjan> boredom -> Special:Random -> Kit Osbourne -> Combat Zone Wrestling -> Philadelphia -> Gentrification -> Property tax -> Mill (currency) -> Latin -> Ancient Greek which we've hit before
18:54:15 <oklopol> we got a strong acceptance to STACS 2012!
18:54:16 <lambdabot> oklopol: You have 1 new message. '/msg lambdabot @messages' to read it.
18:54:45 -!- derrik has joined.
18:54:58 <oklopol> elliott_: about that message, didn't i then prove the theorem?
18:55:18 <oerjan> Ancient Greek still leads roundabout to Greek language :P
18:55:42 <oklopol> also, other reviewers may or may not have given us equally great reviews.
18:56:08 <oklopol> and some of them may or may not have pointed out a full page listing of typos and thinkos
18:56:29 <elliott_> oklopol: can you prove a lil' theorem oerjan needs
18:56:50 <oklopol> which one
18:57:23 <oerjan> hm this was one of the really long ones, still passing through Human (after Ngevd's very temporary cycle i feel like rechecking where this one goes; no change so far i think)
18:57:44 <elliott_> oklopol: oh it's just a simple one, proving the equivalence of two really simple functions
18:57:46 <elliott_> isn't that right oerjan
18:57:53 <Ngevd> Did we ever come to a conclusion on differentiation chains?
18:58:00 <elliott_> oerjan's just not smart enough to do it you see
18:58:00 <oklopol> yeah oerjan solved it
18:58:12 <Ngevd> The answer was?
18:58:18 <elliott_> Ngevd: answer to what
18:58:22 <oklopol> just look at e^(ax)
18:58:31 <oerjan> elliott_: are you talking about the ZipList stuff? i think it's pretty clear in principle.
18:58:41 <oklopol> and choose a fittingly
18:58:49 <oklopol> but oerjan: did you get uniqueness from that?
18:59:12 <oklopol> i think you then get that from taylor series with little trouble for analytic functions
18:59:16 <oerjan> oklopol: i didn't actually _give_ the proof, i just recalled what i remembered as the answer
18:59:53 <oklopol> i consider e^(ax) a proof of existence, but okay so you know it's unique
19:01:41 <oerjan> oklopol: i'm pretty sure, although i don't recall how it goes, it's probably some linear operator proof
19:02:36 -!- Phantom_Hoover has joined.
19:02:43 <oerjan> also i think you need only something like C^n functions to make it so
19:03:08 <oerjan> ...well, it's obviously C^infty once something _is_ a solution.
19:08:29 <oerjan> oklopol: oh it may involve one of the basic extension theorems for differential equations - if the values of a solution function and its n-1 first derivatives at a point are given, then its extension to some neighborhood is unique and by some linear algebra some linear combination of the e^(ax) things obviously fits.
19:09:19 <oerjan> iirc
19:13:01 <oerjan> ah the Human article after a while actually reaches Ngevd's Valuation (finance)
19:14:41 <oerjan> so basically this path is ridiculously long
19:15:01 -!- GreaseMonkey has joined.
19:15:18 <Ngevd> I think I first encountered that loop via Human Population...?
19:15:22 <Ngevd> I started at "chess"
19:15:51 <oerjan> oh wait sorry it wasn't one of Ngevd's anyway, he had Valuation of options -> Option (finance) at one point
19:15:57 <Phantom_Hoover> Oh, did they remove the philosophy loop?
19:15:59 <oerjan> which is similar but not the same
19:16:08 <oerjan> Phantom_Hoover: we are not doing the same game
19:16:15 <Phantom_Hoover> Ah.
19:17:16 <oerjan> we are looking at the last link of the introduction section, which tends to give _rather_ longer paths
19:17:30 <oerjan> but still has some commonly occuring end cycles
19:17:46 -!- kmc has joined.
19:18:23 <elliott_> oerjan: hm i wonder what the longest cycle on wikipedia in _general_ is
19:18:33 <elliott_> i.e. picking which link to follow by a magic oracle that picks the one that leads to the longest cycle :P
19:19:11 <oerjan> ah now reaching President of the United States. i don't believe anything has changed on this path since last time
19:20:10 <oerjan> elliott_: hm i wonder what would be an algorithm for that. in fact isn't that hamiltonian-cycle like, so likely NP-complete
19:20:16 -!- derrik has quit (Ping timeout: 240 seconds).
19:20:59 <elliott_> oerjan: http://en.wikipedia.org/wiki/Longest_path_problem ?
19:21:06 <elliott_> NP-complete, apparently
19:21:07 <oerjan> that is, solving it requires at a minimum finding out whether there is a hamiltonian cycle
19:21:07 <elliott_> :(
19:21:08 <oklopol> could even be harder, but certainly at least as hard as hamiltonian.
19:21:18 <elliott_> oklopol: hamiltonian hard, it seems
19:21:23 <elliott_> godo term that
19:21:25 <elliott_> hamiltonian hard
19:21:49 <oerjan> well it's the usual meaning of "hard" in complexity theory
19:22:05 <oklopol> that's just hardness / completeness of the decision problem. but wait, that's enough.
19:22:16 <oklopol> then just do a binary search
19:22:26 <oerjan> that's the way it usually goes
19:22:34 <oklopol> err
19:22:41 <oerjan> assuming the decision problem has a suitable parameter to search by
19:23:08 <oklopol> except nono, a nondeterministic tm cannot necessarily show that something is not doable
19:23:27 <oklopol> or that some length cannot be done
19:24:27 <oerjan> oklopol: well of course. you end up with the oracle class P^NP
19:24:46 <oklopol> so we agree that it's probably not np-complete
19:24:56 <oerjan> np-hard, is the term :P
19:25:16 <oklopol> obviously i know that, since i just used it
19:25:24 <oerjan> which is obvious from hamiltonian-hard + hamiltonian being NP-complete
19:26:12 <oklopol> basically we'd need to show it's in co-np i guess
19:26:55 <oerjan> erm
19:27:14 <oklopol> i mean
19:27:22 <oerjan> it's likely to be hard for _both_ NP and co-NP, i'd think
19:27:48 <oklopol> but if the decision problem is in both np and co-np, then isn't the problem of actually finding the longest path in np
19:28:20 <oklopol> since you can then do binary search within np
19:28:30 <oerjan> NFP
19:28:40 <oklopol> well sure
19:28:56 <oerjan> or wait
19:29:11 <oklopol> please stop arguing about terminology and start agreeing with everything i say
19:29:11 <Vorpal> ais523: there?
19:29:35 <ais523> yes
19:29:37 <oerjan> FNP, was it
19:29:40 <Vorpal> ais523: know anything about Dungeons of Dreadmor? All I know it is a rouge like, and was added to the last humble bundle.
19:29:45 <ais523> I don't
19:29:47 <Vorpal> So I figure you might know if it is any good
19:29:47 -!- MDude has quit (Ping timeout: 248 seconds).
19:29:48 <Vorpal> ah okay
19:29:50 <oklopol> fnp
19:29:57 <Vorpal> well I'll give it a try
19:30:35 <oklopol> functions calculabilated in nondeterministic polynomial time
19:30:35 <oerjan> well, maybe. it looks a little tricky.
19:30:45 <Vorpal> heh, difficulty setting: elves (easy), dwarves (normal), going rouge (hard). Plus a permadeath option
19:30:53 <Vorpal> hm what to chose
19:31:03 <Vorpal> I'm tempted to go for the nethack way of doing it
19:31:31 <Gregor> Going rouge ... SO RED ... SO RED IT HURTS MY EYES
19:31:43 <Vorpal> typoed that :P
19:31:54 <Vorpal> rogue of course
19:31:58 <oklopol> get an upper bound for biggest value, then do binary search, starting both the np algo and the np algo for the complement at the same time, one of them returns true in polynomial time, continue for linearly many steps to reach value
19:32:10 <oerjan> hm we're on to South Korea, i vaguely recall we may be on the way to the Petronas Towers cycle
19:32:16 <oklopol> no?
19:32:22 <Vorpal> okay no class selection. Instead you select 5 skills from a set of... ~40
19:32:56 <Vorpal> actually 7 out of 34. I fail at counting today
19:33:01 <Vorpal> and there is a random button
19:33:03 <oklopol> running the algos at the same time is a polynomial increase, and there's a linear bound on the length of the upper bound
19:33:27 <oerjan> oklopol: well i'm just not quite sure that's what they meant by FNP in wikipedia
19:33:42 <elliott_> oerjan: hmph now i really want to know the longest cycle in wikipedia :P
19:33:47 <elliott_> oerjan: how many years do i gotta wait to bruteforce it
19:34:09 <oklopol> oerjan: that's the definition of NP imo :D
19:34:43 <oerjan> oklopol: er NP is decision problems. you are trying to calculate a function problem, which obviously has a different name.
19:34:51 <Vorpal> no race selection
19:35:09 <oerjan> i'm just not sure wikipedia's FNP is precisely the class you are using.
19:35:24 <oerjan> it had this strange relation definition
19:35:51 <elliott_> oerjan: HOW MANY YEAAAAAAARS
19:35:57 <oerjan> oh it has its own article too, i just looked at FP
19:36:15 <oklopol> oerjan: yeah but i mean fnp has nothing to do with the class fnp in complexity theory imo
19:36:25 <oerjan> elliott_: get to the singularity first, and we can start estimating
19:36:28 <oklopol> that's just the language of witnesses
19:36:35 <elliott_> oerjan: cries
19:36:35 <oklopol> or whatever they like to call it
19:36:40 <elliott_> oklopol: how many years !!!!
19:36:52 <Ngevd> elliott_: 14
19:37:06 <oerjan> elliott_: there is of course a possibility that wikipedia's graph allows for some greatly simplifying optimizations
19:37:24 <oklopol> i just checked the definition of fnp in my book and it's definitely the relations computable by a nondeterministic turing machine.
19:37:33 <elliott_> oerjan: well paths are very short in general
19:37:47 <oklopol> in the sense that you get nondeterministic output from your tm
19:37:59 <oklopol> but let me check again, actually...
19:38:03 <Vorpal> ais523: so far it seems like a good rougelike. Good game music too. It doesn't take itself seriously though.
19:38:17 <ais523> that's also often good in roguelikes
19:38:20 <elliott_> oerjan: "If you follow the best route in all cases, it takes an average of 4.573 clicks to get from any Wikipedia article to any other."
19:38:51 <oerjan> "Bellare and Goldwasser showed in 1994 using some standard assumptions that there exist problems in NP such that their FNP versions are not self-reducible, implying that they are harder than their corresponding decision problem.
19:38:55 <ais523> elliott_: I wonder what the value is not counting orphan and linkless?
19:38:55 <oerjan> "
19:39:16 <oklopol> so.
19:39:31 <elliott_> ais523: "Wikipedia has 2301486 articles with 55550003 links between them (at least in my dataset, those numbers have definitely changed by now). The largest "strongly-connected-component" of wikipedia has 2111480 articles. That is, there are 2111480 articles with the property that from any of them, it is possible to get to any other one. The rest are mostly pages that no-one has linked to or disambiguation pages. For the graph-theory nerds, there is no
19:39:31 <elliott_> other disjoint strongly connected component of more than about 3 articles. For everyone else, the remaining 190006 articles are pretty boring, linkwise."
19:39:34 <elliott_> ais523: so i doubt it'd change much
19:39:46 <ais523> ah, interesting
19:39:52 <Ngevd> Screw this, I'm getting the latest humble indie bundle
19:39:56 <oklopol> fnp, in my book, is not even anything, they use the terms NPMV and NPSV for multi- and single-valued functions calculated by a tm
19:40:02 <oerjan> elliott_: um i was assuming you wanted to always take the _worst_ route
19:40:05 <elliott_> oerjan: well yes
19:40:08 <oklopol> fp is what it should be
19:40:09 <ais523> wow, someone's probably been looking carefully for walled gardens
19:40:12 <elliott_> oerjan: i was just telling you the only thing i knew about wikipedia's graph :P
19:40:15 <ais523> (articles linking to each other but not to articles in general)
19:40:16 <elliott_> ais523: that was in 2008
19:40:32 <Vorpal> ais523: well yeah, it is graphical of course. What else would one expect from a modern game. Oblique graphics (I think the term is, like isometric but aligned with one axis)
19:40:33 <elliott_> ais523: I think it's more infoboxes
19:40:37 <elliott_> and obsessive linking of dates
19:40:38 <elliott_> and thinks like that
19:40:39 <elliott_> *things
19:40:41 <elliott_> and countries
19:40:43 <ais523> elliott_: those only go one way
19:40:47 <elliott_> well, OK
19:40:48 <ais523> that doesn't lead to a strongly connected component
19:40:51 <ais523> unless it goes both ways
19:41:24 <elliott_> "In the complexities below, I just use "n" to denote either number of nodes or number of edges. Since the graph is so sparse, they're mostly interchangeable."
19:42:05 <Phantom_Hoover> Graphs? Complexity? This is Eodermdrome, right?
19:42:26 <Ngevd> I had an idea for another graph-based esolang
19:42:41 <Ngevd> But then I remembered I still need to finish Salesman
19:42:43 <oerjan> Petronas Towers it was.
19:42:57 <elliott_> Phantom_Hoover: wikipedia
19:43:19 <oerjan> elliott_: wikipedia as an eodermdrome program. discuss.
19:43:20 <Phantom_Hoover> Wikidermdrome.
19:43:25 <Vorpal> ais523: the game has some interesting name for your basic stats. I think "burliness" is it's name for "strength" and so on
19:43:33 <elliott_> heh
19:43:34 <Vorpal> sagacity is probably int I guess?
19:43:42 <Phantom_Hoover> Vorpal, stat names are always a sign of quality!
19:43:42 <Vorpal> caddishness I don't know
19:43:49 <oerjan> well i suppose eodermdrome state fits better.
19:43:52 <Phantom_Hoover> Caddishness, I assume, would be charisma.
19:44:01 <Vorpal> Phantom_Hoover: no but in this case a sign that the game is not taking itself seriously at all.
19:44:32 <Vorpal> there is nimbleness (dex I presume), savvy (wis?) and stubbornness (?)
19:45:53 <Ngevd> help how do I install .rpm
19:45:58 <Vorpal> a traffic cone as a helmet... heh
19:46:21 <Phantom_Hoover> Ngevd, is this a Humble Bundle thing?
19:46:24 <Ngevd> Yes
19:46:28 <Ngevd> DEFCON
19:46:46 <Ngevd> Ooh, there's a .deb
19:46:47 <Vorpal> Ngevd: just use the .tar.gz?
19:46:49 <Vorpal> or that
19:46:49 <Ngevd> .debs are easy
19:46:49 <Phantom_Hoover> I'd just download the .gz, TbH.
19:47:25 <Phantom_Hoover> Much less fuss, and it's not like adding a launcher (the only serious advantage of a .deb in this context) isn't much work.
19:49:39 * Phantom_Hoover purges SpaceChem, uses APT again.
19:49:42 <elliott_> Um.
19:49:45 <elliott_> The .deb is not much less fuss.
19:49:51 <elliott_> You can literally double click them to install.
19:49:58 <elliott_> *more fuss
19:50:01 <elliott_> Ngevd: Use the .debs.
19:50:23 <Ngevd> I was only not using the .debs because of momentary selective blindness
19:51:06 <Vorpal> wand of laser
19:51:43 <Ngevd> Is it bad that so far my favourite roguelike is Pokmon Mystery Dungeon Red Rescue Team?
19:52:18 <Vorpal> ais523: the description of wand of laser is funny: "Aside from tangential properties, this wand's primary magical power involves distracting cats"
19:52:41 <Vorpal> pretty effective still
19:53:09 <Vorpal> stats are "entropy: 27, burn rate: 15" whatever that means
19:53:30 <Phantom_Hoover> Perhaps it's describing the standard entropy value.
19:53:58 <Vorpal> oh okay the tutorial just told me, it has a chance of burnout when used based on entropy and entropy increases with every use
19:54:10 <Vorpal> not sure about burn rate though
20:02:11 <ais523> Ngevd: no, it's a pretty good roguelike
20:02:33 <ais523> Explorers of Time/Darkness/Sky is better, though; Sky removed a lot of rough edges but added a couple of silly mechanics, but it's probably still the best of the three
20:02:39 <ais523> the problem is that it starts out far too easy
20:02:44 <ais523> (all three, that is)
20:07:07 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
20:08:12 -!- zzo38 has joined.
20:09:21 -!- Phantom_Hoover has joined.
20:11:49 <elliott_> oerjan: thanks for reminding me of that six degrees of wikipedia thing, followed some links and the guy has an interesting series of haskell posts on his blog :P
20:12:27 -!- BeholdMyGlory has quit (Ping timeout: 248 seconds).
20:12:47 <oerjan> yw
20:13:39 <elliott_> unfortunately it involves arrows so i don't understand it :'(
20:15:19 <zzo38> Can Applicative be defined in terms of fmap and pure and (liftA2 (,)) instead of (<*>) and pure?
20:15:42 <oerjan> zzo38: yes, i said.
20:16:55 <oerjan> fm <*> x = uncurry ($) `fmap` liftA2 (,) fm x
20:18:52 <oerjan> also i mentioned that a blog comment called it lax monoidal category or something like that
20:33:34 <Gregor> <Gregor> Please describe in glowing terms the inventor of IRP.
20:33:34 <Gregor> <FreeFull> I have no idea who invented IRP
20:33:34 <Gregor> <Gregor> :(
20:33:45 <Gregor> (In #irp )
20:34:12 <oerjan> SIC TRANSIT GLORIA MVNDI
20:36:55 <elliott_> Gregor: Can you go back in time and not invent IRP?
20:37:23 <Gregor> elliott_: If I hadn't invented IRP, you couldn't have even just requested that in IRP#esoteric NOW COULD YOU
20:40:31 <olsner> IRP, is that the internet relay programming or whatchamacallit?
20:40:48 <elliott_> No.
20:40:54 <elliott_> IRP is Ignorant Rabbi Preachers.
20:40:58 <elliott_> Gregor is one.
20:41:16 <oerjan> why am i suddenly having this deja vu feeling
20:41:40 <oerjan> `log [i]gnorant rabbi preachers
20:42:08 <HackEgo> 2011-11-30.txt:20:40:54: <elliott_> IRP is Ignorant Rabbi Preachers.
20:43:36 <oerjan> i guess i must have loaded from a saved game, or something.
20:43:49 <elliott_> oerjan: you know how temperamenatl `log is :P
20:43:57 <elliott_> or does synchronicity guarantee that it would have given the right result
20:43:59 <oerjan> `log [i]gnorant rabbi preachers
20:44:06 <HackEgo> 2011-11-30.txt:20:42:08: <HackEgo> 2011-11-30.txt:20:40:54: <elliott_> IRP is Ignorant Rabbi Preachers.
20:44:40 <oerjan> elliott_: it doesn't look _overly_.
20:44:56 <oerjan> there would be another word if my brain were working.
20:47:41 <olsner> "were"? how many brains do you have?
20:48:02 <oerjan> in which we learn that olsner doesn't know about the subjunctive.
20:49:36 <oerjan> i'm starting to worry about my increasing snarkiness. slightly.
20:49:38 <elliott_> *sigh* this troll on reddit hasn't replied to the second-last phase of my argument
20:51:51 <olsner> oerjan: hmm, is that the subjunctive? can you combine subjunctive with if?
20:52:02 <oerjan> pretty sure
20:52:59 <oerjan> in fact i suspect that's the _majority_ of uses
20:55:32 -!- augur has quit (Read error: Connection reset by peer).
20:57:48 <olsner> oh well.. I'm not the authority on moods anyway, not even the subjunctive one
20:59:36 <elliott_> oerjan: your original line was slightly awkward-seeming btw
20:59:46 <oerjan> which one?
20:59:47 <elliott_> but not wrong at all
20:59:51 <elliott_> <oerjan> there would be another word if my brain were working.
20:59:58 <elliott_> "there would be another word were my brain working" seems better to me
21:00:06 <oerjan> aha
21:00:47 <oerjan> which of course looks more awkward to _me_, but... :P
21:01:00 <olsner> aha! told ya the if was wonky
21:01:55 <elliott_> oerjan: well the whole thing is kind of awkward, it doesn't feel like the way someone would talk without trying to
21:02:42 <oerjan> Quiet, Thou
21:03:09 <olsner> talking without trying to is also awkward
21:03:22 <oerjan> nah is fohel askgaøla gloher
21:03:26 <olsner> ... were it to happen
21:24:15 -!- augur has joined.
21:32:47 <elliott_> oerjan: heh i just realised that arrow notation having banana brackets is funny
21:33:03 <oerjan> O KAY
21:33:12 <elliott_> oerjan: do you
21:33:13 <elliott_> get it
21:33:19 <oerjan> no.
21:33:26 <elliott_> oerjan: time flies like a
21:33:32 <elliott_> *n
21:33:39 * oerjan swats elliott_ -----###
21:33:45 <elliott_> :'(
21:33:49 <elliott_> crying
21:33:56 <oerjan> there was a banana fly on your head
21:34:52 <elliott_> oerjan: (do you (understand arow,)es)
21:35:04 <oerjan> no one does
21:35:29 <oerjan> even oleg just pretends they're applicatives + category
21:35:56 <elliott_> oerjan: i have not found that to help, seeing as I failed to derive arr from Applicative + Category without looking it up :P
21:36:01 <elliott_> ((<$> id))
21:36:09 <oerjan> funny that
21:36:25 <elliott_> are you implyig im stupid :(
21:37:25 <oerjan> nah just retired
21:37:36 * elliott_ cry
21:37:55 <oerjan> lack of oxygen.
21:38:33 <Vorpal> elliott_: you know about weird C++ stuff right?
21:38:42 <elliott_> Phantom_Hoover: kill oerjan , to die for, insult with old meme
21:38:53 <elliott_> Vorpal: i AM weird C++ stuff --leonardo de vinci
21:38:57 <elliott_> *da
21:38:58 <Phantom_Hoover> wha
21:39:05 <elliott_> oh wai
21:39:06 <elliott_> t
21:39:10 <oerjan> obnoxious meme is obnoxious
21:39:10 <elliott_> da is actually rihght
21:39:11 <Vorpal> elliott_: any idea why foo might not work (due to "'foo' was not declared in this scope") while this->foo works perfectly?
21:39:13 <elliott_> that was meant to be a funny joke
21:39:15 <elliott_> oops.
21:39:19 <Vorpal> elliott_: templates are involved
21:39:29 <elliott_> Vorpal: is this a puzzle or can i see code
21:39:57 <Vorpal> elliott_: it is from darwinia source, trying to get it to compile. Adding this-> worked. I don't think I'm legally allowed to paste it just like that.
21:40:09 <elliott_> Vorpal: i own the bundle.
21:40:19 <Vorpal> elliott_: well I need to paste it to you in private then, sec
21:41:55 * oerjan wonders if internet memes will be like fashion, and recycle in a few decades
21:42:17 <Phantom_Hoover> xkcd did a comic on that, although I can't remember if it was pre- or post-decay.
21:42:26 <elliott_> oerjan: http://xkcd.com/286/
21:42:31 <elliott_> Phantom_Hoover: WAY AHEAD OF YOU
21:42:47 <Phantom_Hoover> Pre-decay, then.
21:42:57 <oerjan> all your memes are belong to us
21:43:16 <Phantom_Hoover> Retroturn.
21:43:32 <olsner> hmm, when was aybabtu?
21:44:24 <fizzie> "-- became an Internet phenomenon or meme in 2000–2002."
21:44:25 <lambdabot> fizzie: You have 1 new message. '/msg lambdabot @messages' to read it.
21:44:31 <Vorpal> elliott_: see /msg
21:44:32 <fizzie> Why ask a random channel when you can ask Wikipedia?
21:44:53 <olsner> I asked first, then I went to wikipedia and waited for someone to repeat the information I just read there
21:45:05 <olsner> or a funnier answer
21:45:14 <elliott_> fizzie: YOUR MISTAKE WAS SPEAKING
21:45:33 <fizzie> Most of what I speak is like that.
21:48:33 <elliott_> fizzie: Oh, you're cheating.
21:48:37 <elliott_> You can't speak and then chat like that.
21:48:41 <elliott_> *cheat
21:49:38 -!- Patashu has joined.
21:59:08 -!- Taneb has joined.
22:02:11 -!- Ngevd has quit (Ping timeout: 245 seconds).
22:02:22 -!- MDude has joined.
22:04:22 -!- oerjan has quit (Quit: Good night).
22:07:04 -!- lambdabot has quit (Quit: #lesswrong).
22:18:17 -!- Jafet has quit (Quit: Leaving.).
22:20:16 <elliott_> Deewiant: Test the Windows build already
22:20:26 <Vorpal> elliott_: help
22:22:05 <ais523> <mikehart> Just noticed my email in my account settings was 0.034064395384923 I asume that was the issue.
22:22:09 <ais523> hahaha
22:22:20 <ais523> (it seems to be back to normal now…)
22:23:01 -!- elliott_ has quit (Read error: Operation timed out).
22:26:29 <Phantom_Hoover> http://www.youtube.com/watch?v=rzXOVbYUamc
22:26:36 <Phantom_Hoover> Conclusion: quintopia should live in IKEA.
22:30:37 -!- ais523 has quit (Remote host closed the connection).
22:50:22 <Vorpal> <Phantom_Hoover> http://www.youtube.com/watch?v=rzXOVbYUamc <-- cool
23:20:02 * Phantom_Hoover → sleep
23:20:04 -!- Phantom_Hoover has quit (Quit: Leaving).
23:20:12 <Taneb> Good idea
23:42:12 -!- Taneb has quit (Ping timeout: 260 seconds).
23:57:17 -!- Klisz has joined.
←2011-11-29 2011-11-30 2011-12-01→ ↑2011 ↑all