←2011-01-30 2011-01-31 2011-02-01→ ↑2011 ↑all
00:04:37 <zzo38> th3b0m: One more thing: Next time you connect to IRC, you will need to give your password that you registered your name with. If your IRC client has a prompt for a password anywhere, enter it there.
00:13:37 <th3b0m> yep will do
00:17:23 <oerjan> ^ul ((*)(*))(~:^*a~^Sa*~:^):^
00:17:23 <fungot> ************************************************************************************************************************************************************************************************************************************************************************************************************************************ ...too much output!
00:17:26 <oerjan> er
00:17:36 <oerjan> ^ul ((*)(*))(~:^*a~^(/)*Sa*~:^):^
00:17:36 <fungot> */*/**/***/*****/********/*************/*********************/**********************************/*******************************************************/*****************************************************************************************/********************************************************************************* ...too much output!
00:19:31 <oerjan> ^ul (()(*))(~:^:S*a~^a~!~*~:(/)S^):^
00:19:31 <fungot> */*/**/***/*****/********/*************/*********************/**********************************/*******************************************************/*****************************************************************************************/********************************************************************************* ...too much output!
00:20:03 <oerjan> hm mine is shorter than the wiki's
00:20:20 <zzo38> oerjan: Are you able to help with TeXnicard at all? Alternatively, can you suggest what additional functions you think should be predefined in Plain TeXnicard (the "plain.cards" file)?
00:20:30 <oerjan> nope
00:20:41 <zzo38> oerjan: Can you shorten: ((*)(*)) to ((*):) ?
00:20:48 <oerjan> hm true
00:21:23 <oerjan> ^ul ((*):)(~:^*a~^(/)*Sa*~:^):^
00:21:23 <fungot> */*/**/***/*****/********/*************/*********************/**********************************/*******************************************************/*****************************************************************************************/********************************************************************************* ...too much output!
00:22:44 <quintopia> is that the shortest way to produce exponentially growing output in ul?
00:22:58 <oerjan> nah
00:23:26 <elliott> I think that's quite easy because you have multiplication
00:23:28 <oerjan> ^ul (*)(~:*:(/)*S~:^):^
00:23:28 <fungot> **/****/********/****************/********************************/****************************************************************/********************************************************************************************************************************/*************************************************************** ...too much output!
00:23:30 <elliott> ^ is exponentiation
00:23:31 <elliott> after all
00:23:34 <elliott> that's why it's called ^
00:24:39 <quintopia> o
00:24:49 <elliott> let's see...
00:24:56 <elliott> how do i turn (a)(b) into (a)(a)(b)
00:25:09 <oerjan> bit tricky
00:25:15 <elliott> (a)(b) -~> (b)(a) -:> (b)(a)(a) ... hmm
00:25:18 <elliott> oerjan: I know you can do dip
00:25:20 <elliott> but I've forgotten how
00:25:26 <elliott> I think it involves ^
00:25:35 <elliott> a(foo)~*^
00:25:38 <elliott> executes foo dipped
00:25:48 <elliott> ^ul (a)(b)a(:)~*^^^^
00:25:48 <fungot> ...bad insn!
00:25:51 <elliott> ^ul (a)(b)a(:)~*^SSS
00:25:51 <fungot> baa
00:25:59 <elliott> hm or not
00:26:00 <elliott> oh wait no
00:26:03 <oerjan> ^ul (a)(b)~a:*~*^SS
00:26:03 <fungot> ...bad insn!
00:26:03 <elliott> that's correct
00:26:04 <elliott> no it isn't
00:26:07 <oerjan> argh
00:26:12 <elliott> ^ul (a)(b)a(~:)~*^SSS
00:26:13 <fungot> ...out of stack!
00:26:13 <oerjan> oh
00:26:14 <elliott> ^ul (a)(b)a(~:)~*^SS
00:26:14 <fungot> ...out of stack!
00:26:23 <oerjan> ^ul (a)(b)a~a:*~*^SS
00:26:23 <fungot> ba
00:26:23 <elliott> i'll wait until oerjan writes a b -> a a b, and then write the rest :
00:26:23 <elliott> :P
00:26:32 <oerjan> i just missed an a
00:26:35 <elliott> ^ul (a)(b)a~a:*~*^SSS
00:26:36 <fungot> baa
00:26:38 <elliott> yay
00:27:32 <elliott> ^ul (:*)()a~a:*~*^^S
00:27:32 <fungot> :*
00:27:36 <elliott> ^ul (:*)()a~a:*~*^^SS
00:27:37 <fungot> :*:*
00:27:38 <elliott> yay
00:27:56 <elliott> oerjan: how do you do a simple infinite loop again?
00:27:59 <elliott> ah, wait
00:28:01 <elliott> if i have dip
00:28:04 <elliott> then I can just do
00:28:08 <elliott> oerjan: what's dip again?
00:28:09 <elliott> :p
00:28:15 <zzo38> (:^):^
00:28:16 <oerjan> ^ul (a)(b)(:)~a*^SSS
00:28:16 <fungot> baa
00:28:20 <elliott> oerjan: that's not dip
00:28:27 <oerjan> um yes it is
00:28:32 <elliott> oh, right
00:28:33 <elliott> thanks :P
00:28:55 <zzo38> ^ul (:^):^
00:28:56 <fungot> ...out of time!
00:29:02 <elliott> ^ul (:*)()((a~a:*~*^^S)~a*^:^):^
00:29:02 <fungot> :* ...out of stack!
00:29:04 <elliott> damn
00:29:11 <elliott> that's meant to be 2^1, 2^2, 2^3, ...
00:29:20 <elliott> basic code structure:
00:29:41 <elliott> 2 1 { { [[a b -> a a b]] exponentiate print } dip dup exec } dup exec
00:29:44 <elliott> is that wrong?
00:30:39 <oerjan> ...presumably
00:30:48 <zzo38> It would mean something similar that you did could also be used in TeXnicard to manipulate the stack this way, although you would ordinarily do it with temporary variables instead, probably (like in dc).
00:31:01 <oerjan> a b -> a a b is not a way to increment a number, anyway
00:31:21 <zzo38> I wrote a way to increment a number in the Talk:Underload page in the wiki.
00:31:54 <elliott> oerjan: i wasn't incrementing it...
00:31:57 <elliott> oerjan: it's recursive
00:32:06 <elliott> oerjan: f(0) = 1; f(n+1) = 2^f(n)
00:32:17 <elliott> oerjan: done iteratively: x=1; while true: x=2^x
00:32:20 <elliott> oerjan: duh :P
00:32:29 <elliott> oerjan: the duplication is to turn
00:32:30 <oerjan> ok
00:32:34 <elliott> 2 exponent -> 2 2 exponent
00:32:39 <elliott> then exponentiate with ^:
00:32:43 <elliott> 2 (2^exponent)
00:32:47 <elliott> which becomes the new exponent
00:33:54 -!- Behold has joined.
00:34:01 <elliott> oerjan: so my loop must be wrong
00:34:14 <elliott> <elliott> ^ul (:*)()a~a:*~*^^S
00:34:14 <elliott> <fungot> :*
00:34:15 <fungot> elliott: is evoli whitewashed? :p
00:34:16 <elliott> that's the program sans loop
00:34:27 <elliott> ^ul (:*)()a~a:*~*^^S(/)S
00:34:27 <fungot> :*/
00:34:36 <Deewiant> Without knowing any underload: if you print the exponent, don't you need to dup it first to not lose it
00:34:43 <elliott> Deewiant: er yes thanks :P
00:34:53 <elliott> oerjan: (:*)(){a~a:*~*^^:S(/)S} -- this is the program, where {} is an infinite loop
00:35:19 <elliott> ^ul (:*)()((a~a:*~*^^:S(/)S)~a*^:^):^
00:35:19 <fungot> :*/:*:*/:*:*:*:*/:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*/ ...too much stack!
00:35:21 <elliott> yay
00:35:23 <elliott> exponential, see!
00:35:28 <elliott> <oerjan> ^ul (*)(~:*:(/)*S~:^):^
00:35:30 <elliott> darn oerjan's is shorter
00:35:45 <oerjan> mine only does n -> 2*n
00:35:55 <elliott> oerjan: but the result is still exponential
00:35:56 <elliott> because of unary
00:36:02 <elliott> er wait
00:36:03 <elliott> no it's not
00:36:21 <oerjan> um yes
00:36:27 <elliott> er, yes
00:36:37 <zzo38> Deewiant: Do you know dc?
00:36:49 <Deewiant> Barely at all
00:36:56 <elliott> ^ul (:*)()((a~a:*~*^^:(/)*S(/))~a*^:^):^
00:36:56 <fungot> :*/ ...bad insn!
00:37:01 <elliott> ^ul (:*)()((a~a:*~*^^:(/)*S)~a*^:^):^
00:37:01 <fungot> :*/:*:*/:*:*:*:*/:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*/ ...too much stack!
00:37:05 <elliott> ^ul (:*)()((a~a:*~**^:(/)*S)~a*^:^):^
00:37:06 <fungot> ...out of stack!
00:37:11 <elliott> ^ul (:*)()((a~a:*~*^*:(/)*S)~a*^:^):^
00:37:11 <fungot> :*/:*:*/:*:*:*/:*:*:*:*/:*:*:*:*:*/:*:*:*:*:*:*/:*:*:*:*:*:*:*/:*:*:*:*:*:*:*:*/:*:*:*:*:*:*:*:*:*/:*:*:*:*:*:*:*:*:*:*/:*:*:*:*:*:*:*:*:*:*:*/:*:*:*:*:*:*:*:*:*:*:*:*/:*:*:*:*:*:*:*:*:*:*:*:*:*/:*:*:*:*:*:*:*:*:*:*:*:*:*:*/:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*/:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*/:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*/: ...too much output!
00:37:21 <elliott> ^ul (:*)()((a~a:*~*^^:(/)*S)~a*^:^):^
00:37:21 <fungot> :*/:*:*/:*:*:*:*/:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*:*/ ...too much stack!
00:37:22 -!- BeholdMyGlory has quit (Ping timeout: 255 seconds).
00:37:28 <zzo38> Deewiant: In dc, the p command (but not the P command) keeps the number or string to output on the stack afterward.
00:37:44 <elliott> Deewiant: In dc, every ASCII character is a valid register name.
00:37:44 <Deewiant> I didn't know that.
00:37:56 <Deewiant> I didn't know dc had registers. :-P
00:38:11 <elliott> Deewiant: Yes. And all registers are both strings and stacks!
00:38:13 <zzo38> Deewiant: Yes, dc does have registers. Also, each register can be stashed and retrieved like you can in INTERCAL.
00:38:16 <elliott> It's a delightfully demented little language.
00:38:29 <elliott> Deewiant: Also, functions are just strings.
00:38:34 <zzo38> You can also do something similar to the RESUME command in INTERCAL.
00:39:00 <zzo38> Each register, and any entry on the stack, in dc, can store any string or any number (with arbitrary precision).
00:39:19 <Deewiant> In my mind dc supports integer constants, four arithmetic operations, and dup and print.
00:39:24 <elliott> oerjan: hm why is your program so short
00:39:30 <elliott> Deewiant: No swap? :p
00:39:43 <Deewiant> No, I don't know the command. :-D
00:39:43 <zzo38> Deewiant: There is a GNU extension to dc that supports r for swap.
00:40:01 <elliott> That's an extension? X-D
00:40:39 <Deewiant> My Solaris's dc doesn't have it, so presumably yes.
00:40:43 <oerjan> elliott: which program?
00:40:53 <zzo38> elliott: Yes, although you could do it without extensions by: SaSbLaLb
00:41:03 <oerjan> the exponential one doesn't try any arithmetic, just doubles a string
00:41:03 -!- poiuy_qwert has quit (Quit: This computer has gone to sleep).
00:41:44 <elliott> oerjan: your multiplying one
00:41:47 <elliott> ah
00:42:19 <elliott> Deewiant: gcd in dc: ??[dSarLa%d0<a]dsax+p
00:42:27 <elliott> It even takes input and produces output from the console!
00:42:31 <oerjan> also since there is only one such string, dip can be simplified to just ~'ing the code a bit. well if that actually _is_ a simplification.
00:42:34 <elliott> [a=]P?[b=]P?[dSarLa%d0<a]dsax+[GCD:]Pp
00:42:37 <elliott> THIS ONE HAS PROMPTS.
00:43:01 <oerjan> well i guess it is.
00:43:17 <elliott> oerjan: now rewrite it in underload-minus-()
00:43:36 <zzo38> The ? in dc just takes a line of dc code from stdin and executes it.
00:44:09 <zzo38> Also, you can change the input radix and output radix in dc. This also affects numbers in any subroutines you have stored, so be careful.
00:44:18 <oerjan> elliott: NO THANKS
00:44:35 <elliott> oerjan: it's *easy*, you just turn X into X(X^-1)%
00:44:44 <elliott> *$XX^{-1}%$
00:44:51 <elliott> TEX REDUCES AMBIGUITY
00:45:25 <zzo38> However, in TeX, % starts a comment.
00:46:12 -!- cheater00 has joined.
00:46:55 <elliott> hmm, it looks like errata for my errata were published in mathNEWS but not my actual errata
00:47:44 <zzo38> elliott: Well, mathNEWS sometimes does that. They publish the errata for the errata without publishing the errata.
00:47:51 <elliott> "Sometimes"?
00:47:59 <elliott> I hereby express scepticism that that has happened before.
00:48:00 <olsner> I hate it when that happens to the errata of my errata
00:48:50 <elliott> "Some of you may have noticed an article published earlier in this issue with errata to an article printed in the previous issue of mathNEWS." <-- pretty sure I haven't as it's not bloody here!
00:48:53 <olsner> well, it happens to the errata... or maybe rather it *doesn't* happen to the errata, at least not soon enough
00:48:57 <zzo38> (That is, % starts a comment by default, but you can change the category codes to make it do other things)
00:48:59 <elliott> maybe they decided it was so amazing that it was print-only
00:49:20 -!- cheater- has quit (Ping timeout: 240 seconds).
00:50:00 <elliott> IT APPEARS SO
00:50:01 <olsner> maybe!
00:50:16 <olsner> what was amazing, the errata or the errata for it?
00:50:16 <elliott> I'd yell at coppro to get it fixed but I think I'm still on ignore
00:50:34 <elliott> olsner: the errata, which I wrote
00:50:40 <elliott> the errata for the errata are slanderous and incorrect
00:50:47 <zzo38> elliott: Yes, maybe that is it. But even for print-only things don't they sometimes make a PDF of those parts?
00:50:53 <olsner> oh, you didn't write the errata?
00:50:59 <elliott> seemingly not!
00:51:00 <olsner> *the errata for the errata
00:51:00 <elliott> olsner: yes, i did
00:51:03 <zzo38> I do not see any of coppro's messages on here in the past few hours.
00:51:03 <elliott> olsner: ah, no
00:51:07 <elliott> olsner: that was written by an evil canadian
00:51:17 <olsner> damn the canadians and their errata
00:51:19 <elliott> http://www.mathnews.uwaterloo.ca/Issues/mn11402/ErrataToTheErrata.php this is the meta-errata
00:51:27 <elliott> also, errata errata errata
00:51:33 <elliott> congratulations, you know longer know what the errata "errata" means
00:52:31 <elliott> http://www.google.co.uk/search?sourceid=chrome&ie=UTF-8&q=Errata+for+the+article+%22Python+Implementation+of+ed%22+by+*null,+as+printed+in+issue+114.1+of+the+University+of+Waterloo+Faculty+of+Mathematics+Student+Newspaper+mathNEWS.
00:52:36 <elliott> yep, those bastards don't have it online
00:53:07 <oerjan> <zzo38> I do not see any of coppro's messages on here in the past few hours. <-- according to whois, he hasn't spoken for 7 hours
00:53:32 <elliott> possibly he died.
00:53:41 <olsner> aha, elliott killed him
00:53:47 <elliott> probably
00:53:50 <elliott> fucking canadian
00:53:50 <elliott> s
00:53:58 <elliott> oerjan: well why else would you not talk on irc for 7 hours
00:54:01 <elliott> without telling everyone first
00:54:02 <elliott> hey guys
00:54:04 <elliott> i'm gonna be gone
00:54:04 <elliott> a LONG time
00:54:06 <elliott> but don't worry
00:54:07 <elliott> i'll be fine
00:54:21 <elliott> just gotta
00:54:22 <elliott> sort out some issues
00:54:24 <elliott> like
00:54:26 <elliott> death and stuff
00:54:26 <elliott> so
00:54:27 <elliott> BYE
00:54:41 -!- Behold has quit (Remote host closed the connection).
00:54:57 <oerjan> O KAY
01:01:44 -!- cheater00 has quit (Ping timeout: 240 seconds).
01:04:20 -!- cheater00 has joined.
01:11:30 -!- th3b0m has quit (Quit: Leaving).
01:13:22 -!- zzo38 has quit (Remote host closed the connection).
01:21:17 -!- azaq231 has quit (Quit: Leaving.).
01:23:16 <elliott> @hoogle [a] -> [a] -> [a]
01:23:16 <lambdabot> Prelude (++) :: [a] -> [a] -> [a]
01:23:16 <lambdabot> Data.List (++) :: [a] -> [a] -> [a]
01:23:16 <lambdabot> Data.List deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
01:23:26 <elliott> :t interleave
01:23:27 <lambdabot> forall (m :: * -> *) a. (MonadLogic m) => m a -> m a -> m a
01:23:31 <elliott> > interleave [1,2] [3,4]
01:23:32 <lambdabot> [1,3,2,4]
01:24:10 <elliott> > let int [] ys = ys; int (x:xs) ys = x : int ys xs in int [1,2,3] [4,5,6]
01:24:11 <lambdabot> [1,4,2,5,3,6]
01:24:16 <elliott> > let int [] ys = ys; int (x:xs) ys = x : int ys xs in int [1,2,3] [1,2,3]
01:24:17 <lambdabot> [1,1,2,2,3,3]
01:24:19 <elliott> > let int [] ys = ys; int (x:xs) ys = x : int ys xs in int [1,2,3] [1,2,3,4]
01:24:19 <lambdabot> [1,1,2,2,3,3,4]
01:24:32 <elliott> > length [1,1,2,2,3,3,4]
01:24:33 <lambdabot> 7
01:24:37 <elliott> > 3+4
01:24:38 <lambdabot> 7
01:24:41 <elliott> > let int [] ys = ys; int (x:xs) ys = x : int ys xs in int [1,2,3,4] [1,2,3]
01:24:42 <lambdabot> [1,1,2,2,3,3,4]
01:24:46 <elliott> > length [1,1,2,2,3,3,4]
01:24:47 <lambdabot> 7
01:25:06 <elliott> @check \xs ys -> let int [] ys = ys; int (x:xs) ys = x : int ys xs in int xs ys == int ys xs
01:25:06 <lambdabot> "OK, passed 500 tests."
01:25:09 <elliott> yay
01:25:31 <elliott> :t product
01:25:32 <lambdabot> forall a. (Num a) => [a] -> a
01:25:33 <elliott> @hoogle product
01:25:33 <lambdabot> Prelude product :: Num a => [a] -> a
01:25:33 <lambdabot> Data.Foldable product :: (Foldable t, Num a) => t a -> a
01:25:35 <elliott> @hoogle cartesian
01:26:09 <elliott> > sequence [[],[],[]] [[],[],[]]
01:26:10 <lambdabot> Couldn't match expected type `[[a]] -> t'
01:26:10 <lambdabot> against inferred type `[[...
01:26:20 <elliott> > sequence [[[],[],[]], [[],[],[]]]
01:26:21 <lambdabot> [[[],[]],[[],[]],[[],[]],[[],[]],[[],[]],[[],[]],[[],[]],[[],[]],[[],[]]]
01:26:24 <elliott> :t sequence [[[],[],[]], [[],[],[]]]
01:26:25 <lambdabot> forall a. [[[a]]]
01:26:35 <elliott> :t sequence [[1,2,3], [4,5,6]]
01:26:36 <lambdabot> forall t. (Num t) => [[t]]
01:26:38 <elliott> > sequence [[1,2,3], [4,5,6]]
01:26:39 <lambdabot> [[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]
01:26:43 <elliott> > length $ sequence [[1,2,3], [4,5,6]]
01:26:44 <lambdabot> 9
01:26:55 <elliott> > length $ sequence [[(),(),()], [(),(),(),()]]
01:26:56 <lambdabot> 12
01:27:06 <elliott> > sequence [[(),(),()], [(),(),(),()]]
01:27:07 <lambdabot> [[(),()],[(),()],[(),()],[(),()],[(),()],[(),()],[(),()],[(),()],[(),()],[(...
01:27:16 <elliott> > concat $ sequence [[(),(),()], [(),(),(),()]]
01:27:16 <lambdabot> [(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),(),()]
01:27:24 <elliott> @pl \xs ys -> concat (sequence [xs,ys]_
01:27:25 <lambdabot> (line 1, column 35):
01:27:25 <lambdabot> unexpected "_"
01:27:25 <lambdabot> expecting variable, "(", operator or ")"
01:27:26 <elliott> @pl \xs ys -> concat (sequence [xs,ys])
01:28:39 <elliott> > concat (sequence [[],[]])
01:28:40 <lambdabot> []
01:28:41 <elliott> > concat (sequence [[],x])
01:28:42 <lambdabot> Couldn't match expected type `[a]'
01:28:42 <lambdabot> against inferred type `SimpleRef...
01:28:47 <elliott> > concat (sequence [x,y])
01:28:48 <lambdabot> Couldn't match expected type `[a]'
01:28:48 <lambdabot> against inferred type `SimpleRef...
01:28:53 <elliott> > concat (sequence [[x],[y]])
01:28:54 <lambdabot> [x,y]
01:29:01 <elliott> > concat (sequence [[x],[]])
01:29:01 <lambdabot> []
01:29:05 <elliott> > concat (sequence [[],[y]])
01:29:06 <lambdabot> []
01:30:00 <elliott> > concat (sequence [[x,y],[a,b]])
01:30:01 <lambdabot> [x,a,x,b,y,a,y,b]
01:32:50 <elliott> @check let f _ [] = []; f [] _ = []; f (x:xs) ys = concatMap (\y -> [x,y]) ys ++ f xs ys in \xs ys -> f xs ys == concat (sequence [xs,ys])
01:32:51 <lambdabot> "OK, passed 500 tests."
01:32:53 <elliott> yay
01:33:00 <elliott> @check let f _ [] = []; f (x:xs) ys = concatMap (\y -> [x,y]) ys ++ f xs ys in \xs ys -> f xs ys == concat (sequence [xs,ys])
01:33:01 <lambdabot> "*Exception: <interactive>:3:19-82: Non-exhaustive patterns in function f
01:33:20 <elliott> @check let f _ [] = []; f [] _ = []; f (x:xs) ys = concatMap (\y -> [x,y]) ys ++ f xs ys in \xs ys -> length (f xs ys) == length xs * length ys
01:33:20 <lambdabot> "Falsifiable, after 0 tests:\n[()]\n[()]\n"
01:33:33 <elliott> > let f _ [] = []; f [] _ = []; f (x:xs) ys = concatMap (\y -> [x,y]) ys ++ f xs ys in f [()] [()]
01:33:34 <lambdabot> [(),()]
01:33:50 <elliott> > let f _ [] = []; f [] _ = []; f (x:xs) ys = concatMap (\y -> [x,y]) ys ++ f xs ys in sequence [[()], [()]]
01:33:51 <lambdabot> [[(),()]]
01:33:55 <elliott> > let f _ [] = []; f [] _ = []; f (x:xs) ys = concatMap (\y -> [x,y]) ys ++ f xs ys in sequence [[()], [(),()]]
01:33:56 <lambdabot> [[(),()],[(),()]]
01:34:01 <elliott> > let f _ [] = []; f [] _ = []; f (x:xs) ys = concatMap (\y -> [x,y]) ys ++ f xs ys in sequence [[(),()], [(),()]]
01:34:02 <lambdabot> [[(),()],[(),()],[(),()],[(),()]]
01:34:12 <elliott> hey oerjan
01:34:35 <elliott> what's a list function that obeys |f(xs,ys)| = |xs|*|ys| but has the same depth as the input lists :P
01:36:26 <elliott> oerjan oerjan oerjan oerjan
01:55:15 <oerjan> <lambdabot> forall (m :: * -> *) a. (MonadLogic m) => m a -> m a -> m a <-- eek, more caleskell?
01:57:19 <elliott> oerjan: seemingly!
01:57:40 <elliott> oerjan: <elliott> what's a list function that obeys |f(xs,ys)| = |xs|*|ys| but has the same depth as the input lists :P
02:00:19 <oerjan> :t liftM2 (,)
02:00:20 <lambdabot> forall a1 a2 (m :: * -> *). (Monad m) => m a1 -> m a2 -> m (a1, a2)
02:00:38 <elliott> oerjan: that counts as additional depth
02:00:50 <oerjan> oh.
02:00:59 <elliott> oerjan: specifically, "f [[],[],[]] [[],[],[]]" needs to produce a list of 12 []s
02:01:44 <oerjan> > liftM2 (++) [[],[],[]] [[],[],[]]
02:01:46 <lambdabot> [[],[],[],[],[],[],[],[],[]]
02:01:53 <oerjan> itym 9 right?
02:01:57 <elliott> er yes
02:01:59 <elliott> > liftM2 (++) [1,2,3] [4,5,6]
02:02:00 <lambdabot> Ambiguous type variable `a1' in the constraints:
02:02:00 <lambdabot> `GHC.Num.Num a1'
02:02:00 <lambdabot> a...
02:02:12 <elliott> > liftM2 (++) [[1],[2],[3]] [[4],[5],[6]]
02:02:14 <lambdabot> [[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]
02:02:27 <elliott> oerjan: specifically i'm designing operations for the language where "obj := [] | obj * obj"
02:02:29 <elliott> where * is cons
02:02:36 <elliott> addition is easy, it's just interleave
02:02:39 <elliott> multiplication is hard
02:02:44 <elliott> oerjan: and numerals are just lists of []s i.e.
02:02:48 <elliott> [] * ([] * ... [])
02:02:55 <elliott> oerjan: but ofc the operations have to have some generality :)
02:03:08 <elliott> ok liftM2 (++) might work
02:03:20 <oerjan> well the thing is whatever you use instead of ++ must work for two of your _actual_ list elements
02:03:38 <elliott> oerjan: no, I can use (++)
02:03:43 <elliott> oerjan: obj = [] | cons obj obj
02:03:44 <oerjan> yay!
02:03:50 <elliott> oerjan: obviously, (++) is defined on this :)
02:05:18 -!- cheater00 has quit (Ping timeout: 240 seconds).
02:05:30 <elliott> oerjan: so er what's (liftM2 (++)) recursively...
02:05:44 <elliott> > liftM2 (++) [] [[],[],[]]
02:05:46 <lambdabot> []
02:05:49 <elliott> > liftM2 (++) [[],[],[]] []
02:05:50 <lambdabot> []
02:06:36 -!- cheater00 has joined.
02:11:43 <oerjan> liftM2 _is_ cartesian product, with your choice of combining function
02:12:17 <elliott> oerjan: right. so instead of x:y:... in the combining loop, we do (x++y):...
02:12:20 <elliott> right?
02:12:21 <elliott> erm
02:12:24 <elliott> instead of (x,y):...
02:12:30 <oerjan> yeah
02:15:14 <elliott> oerjan: is that function actually useful :D
02:15:17 <elliott> liftM2 (++) that is
02:15:42 <elliott> wow, part 4 is 20 minutes
02:15:44 <oerjan> i'm sure it must have happened
02:16:13 <oerjan> probably more likely to be written as a list comprehension, though
02:16:14 <elliott> has someone used this haskell function before? does a bear shit in the woods?
02:17:08 <oerjan> maybe for table labels or something...
02:19:15 <oerjan> > liftM2 (++) ["row " ++ show n | n <- [1..3]] [", column " ++ show m | m <- [1..3]]
02:19:17 <lambdabot> ["row 1, column 1","row 1, column 2","row 1, column 3","row 2, column 1","r...
02:19:55 <oerjan> of course that's contrived since it'd probably be combined more
02:21:10 <oerjan> liftM2 (++) might be more likely with another Monad, perhaps...
02:21:44 <oerjan> perhaps in Parsec...
02:22:12 <elliott> oerjan: well (++) also works as addition. although i've chosen interleave, I'm not sure why
02:22:39 <oerjan> :t interleave
02:22:40 <lambdabot> forall (m :: * -> *) a. (MonadLogic m) => m a -> m a -> m a
02:22:50 <elliott> so er [1,2,3] * [4,5,6] = [5,6,7,6,7,8,7,8,9]
02:22:51 <elliott> in my language
02:23:01 <oerjan> :t Data.List.interleave
02:23:02 <lambdabot> Not in scope: `Data.List.interleave'
02:23:09 <oerjan> hum
02:23:10 <elliott> :D
02:23:15 <oerjan> oh i'm thinking of intersperse
02:23:18 <elliott> > interleave [a,b,c] [x,y,z]
02:23:18 <lambdabot> [a,x,b,y,c,z]
02:23:30 <elliott> i don't know why i chose it for addition rather than (++)
02:23:54 <oerjan> @hoogle interleave
02:23:54 <lambdabot> System.IO.Unsafe unsafeInterleaveIO :: IO a -> IO a
02:23:54 <lambdabot> Control.Monad.ST unsafeInterleaveST :: ST s a -> ST s a
02:23:54 <lambdabot> Control.Monad.ST.Lazy unsafeInterleaveST :: ST s a -> ST s a
02:24:00 <oerjan> @more
02:24:08 <oerjan> ARGH
02:24:11 <oerjan> @hoogle interleave
02:24:11 <lambdabot> System.IO.Unsafe unsafeInterleaveIO :: IO a -> IO a
02:24:11 <lambdabot> Control.Monad.ST unsafeInterleaveST :: ST s a -> ST s a
02:24:11 <lambdabot> Control.Monad.ST.Lazy unsafeInterleaveST :: ST s a -> ST s a
02:24:13 <oerjan> @more
02:24:22 <oerjan> doesn't @more work any more?
02:24:40 <elliott> it just hates you
02:24:43 <elliott> sorry.
02:24:49 <elliott> @hoogle interleave :: [a] -> [a] -> [a]
02:24:50 <lambdabot> No results found
02:24:52 <elliott> :D
02:24:57 <elliott> :t intersperse
02:24:58 <lambdabot> forall a. a -> [a] -> [a]
02:25:37 <oerjan> hm they haven't registered hoogle.org
02:25:48 <oerjan> :t intercalate
02:25:48 <lambdabot> forall a. [a] -> [[a]] -> [a]
02:26:07 -!- poiuy_qwert has joined.
02:26:15 <oerjan> @hoogle map :: (a -> b) -> [a] -> [b]
02:26:15 <lambdabot> Prelude map :: (a -> b) -> [a] -> [b]
02:26:15 <lambdabot> Data.List map :: (a -> b) -> [a] -> [b]
02:26:15 <lambdabot> Prelude fmap :: Functor f => (a -> b) -> f a -> f b
02:26:42 <oerjan> @hoogle map :: (a -> b) -> Either [a] Fnord -> Maybe [b]
02:26:42 <lambdabot> Warning: Unknown type Fnord
02:26:42 <lambdabot> No results found
02:26:49 <oerjan> YOU DON'T SAY
02:27:15 <oerjan> @hoogle fap :: (a -> b) -> [a] -> [b]
02:27:15 <lambdabot> No results found
02:32:21 <elliott> :D
02:32:24 <elliott> @hoogle fap
02:32:24 <lambdabot> No results found
02:32:30 <elliott> fmap fmap fmap
02:32:32 <oerjan> @hoogle map :: (a -> b) -> Either [a] Bool -> Maybe [b]
02:32:33 <lambdabot> No results found
02:32:49 <Ilari> IPv6-related term: White Screen of Death.
02:32:56 <oerjan> Ilari: wat
02:33:16 <Ilari> Hoston used that term in his keynote talk in Linux.conf.au...
02:33:56 <Ilari> And for some reason, it had trainwreck theme (nearly every slide had picture of rail disaster...)
02:34:00 <elliott> <oerjan> @hoogle map :: (a -> b) -> Either [a] Bool -> Maybe [b]
02:34:02 <elliott> BEST FUNCTION
02:34:28 <oerjan> elliott: hm it's actually possible i think
02:34:38 <elliott> BEST FUNCTION
02:35:11 <oerjan> :t let map f (Left x) = fmap f x; map f (Right b) = Nothing in map
02:35:11 <lambdabot> forall a b t. (a -> b) -> Either (Maybe a) t -> Maybe b
02:35:22 <oerjan> er no
02:35:35 <oerjan> oh...
02:35:51 <oerjan> :t let map f (Left x) = Just $ fmap f x; map f (Right b) = Nothing in map
02:35:52 <lambdabot> forall a b (f :: * -> *) t. (Functor f) => (a -> b) -> Either (f a) t -> Maybe (f b)
02:36:18 <oerjan> a little more general
02:36:25 <oerjan> hm...
02:36:47 <oerjan> :t let map f (Left x) = Just $ fmap f x; map f (Right False) = Nothing; map f (Right True) = [] in map
02:36:47 <lambdabot> Couldn't match expected type `Maybe (f b)'
02:36:48 <lambdabot> against inferred type `[a]'
02:36:48 <lambdabot> In the expression: []
02:36:50 <oerjan> argh
02:36:55 <oerjan> :t let map f (Left x) = Just $ fmap f x; map f (Right False) = Nothing; map f (Right True) = Just [] in map
02:36:56 <lambdabot> forall a a1. (a -> a1) -> Either [a] Bool -> Maybe [a1]
02:38:06 <oerjan> Ilari: hoston? strange name for a person
02:38:37 * oerjan slightly suspects finnish pronoun failure
02:38:52 <elliott> it's huston or something
02:39:07 <oerjan> i mean hoston would be a _good_ name for an ISP
02:39:14 <elliott> no it's this guy
02:39:22 <elliott> oerjan: (++) or interleave WHAT'S A BETTER ADDITION
02:39:52 <elliott> There are two choices of toilet paper orientation when using a toilet roll holder with a horizontal axle parallel to the wall: the toilet paper may hang over or under the roll. The choice is largely a matter of personal preference, dictated by habit. In surveys of American consumers and of bath and kitchen specialists, 60–70% of respondents prefer over.[1]
02:39:52 <elliott> What surprises some observers, including advice columnist Ann Landers, is the extent to which people hold strong opinions on such a trivial topic. Defenders of either position cite advantages ranging from aesthetics, hospitality, and cleanliness; to paper conservation and the ease of detaching individual squares. Celebrities and experts are found on both sides. Theories abound of what one's choice might say of a person: possibly it indicates age,
02:39:53 <elliott> or gender, or socioeconomic status, or political philosophy; possibly it offers insights into personality traits such as dependability and flexibility; possibly it correlates with ownership of a recreational vehicle or a cat.[2]
02:39:57 <elliott> Solutions range from compromise, to using separate dispensers or separate bathrooms entirely. One man advocates a plan under which his country will standardize on a single forced orientation, and at least one inventor hopes to popularize a new kind of toilet roll holder which swivels from one orientation to the other.[3]
02:40:11 <Ilari> Ah yeah, huston...
02:40:27 <oerjan> :t foldl (flip (:))
02:40:28 <lambdabot> forall b. [b] -> [b] -> [b]
02:40:32 <oerjan> elliott: THAT ONE
02:40:37 <elliott> > foldl (flip (:)) [1,2,3] [4,5,6]
02:40:38 <lambdabot> [6,5,4,1,2,3]
02:41:17 <elliott> oerjan: i guess [1,2,3]+[4,5,6] = [1,2,3,4,5,6] is more Useful, but otoh interleave is a fun function that isn't so trivial to implement in terms of other things
02:41:25 * oerjan is a strict hang over person
02:42:47 <oerjan> also i saw a norwegian page about the subject years ago, it was hang over supporting too
02:43:21 <elliott> i thought you were expressing an opinion on drinking
02:43:28 <elliott> or, making a terrible pun on "huston"
02:43:32 <elliott> because it turned into... hanover
02:43:34 <elliott> and then hang over and what
02:43:40 <oerjan> oh wait i misremembered http://www.home.no/haraldweider/dorull.html
02:43:49 <oerjan> those heretics have it _wrong_
02:44:53 <elliott> you guys are weird
02:46:08 -!- Adiemus has quit (Ping timeout: 276 seconds).
02:46:12 <oerjan> elliott: you seem not to have read the thing you pasted :D
02:46:29 <elliott> excuse me i am asking for opinions
02:46:31 <elliott> <elliott> oerjan: i guess [1,2,3]+[4,5,6] = [1,2,3,4,5,6] is more Useful, but otoh interleave is a fun function that isn't so trivial to implement in terms of other things
02:48:25 <oerjan> elliott: the thing about the function i mentioned is that it's tail recursive in a strict language. of course that's not important for haskell.
02:48:40 <oerjan> @src reverse
02:48:40 <lambdabot> reverse = foldl (flip (:)) []
02:48:51 <elliott> oerjan: well yes, but you have to reverse first :P
02:49:01 <elliott> but i think my language might be lazy.
02:50:10 <oerjan> oh hm
02:50:17 * elliott very much doubts that Slaves to Armok: God of Blood will ever get a second sequel.
02:50:21 <elliott> *third chapter.
02:50:51 <elliott> heh chapter ii was developed for four years before release
02:53:04 <oerjan> > foldr (foldl (flip (:))) "hm..." ["alpha", "beta", "gamma"]
02:53:06 <lambdabot> "ateb...mhgammaalpha"
02:53:18 <oerjan> wtf
02:53:21 <elliott> what :D
02:53:47 <elliott> oerjan: ateb...mhγα
02:53:50 <elliott> hmm what is this LANGUAGE
02:53:51 <oerjan> > foldl (foldl (flip (:))) "hm..." ["alpha", "beta", "gamma"]
02:53:53 <lambdabot> "ammagatebahplahm..."
02:55:01 <oerjan> hm...
02:55:05 <elliott> that would make a good chant
02:55:10 <elliott> AMMA GATE BAHP LAHM
02:55:26 <oerjan> NO! DON'T SUMMON THE AAARGH...
02:56:03 <oerjan> > foldr (flip (:)) 'h' "abc"
02:56:04 <lambdabot> Occurs check: cannot construct the infinite type: b = [b]
02:56:12 <oerjan> > foldr (flip (:)) "h" "abc"
02:56:13 <lambdabot> Occurs check: cannot construct the infinite type: b = [b]
02:56:17 <oerjan> gah
02:56:50 <elliott> why on earth _did_ i decide on it
02:56:51 <elliott> oh
02:56:55 <elliott> it was because of the way I wrote it at first
02:57:04 <elliott> treating Base as 0 and Comp irrelevant x as a natural
02:57:14 <elliott> add Base y = y
02:57:38 <elliott> add (Comp <IRRELEVANT> x) (Comp <IRRELEVANT> y) = Comp <IRRELEVANT> (Comp <IRRELEVANT> (add x y))
02:57:42 <elliott> because Succ = Comp <IRRELEVANT>
02:57:47 <elliott> but we have to bind them
02:57:49 <elliott> so we do it dumbly
02:57:58 <elliott> add (Comp x xs) (Comp y ys) = Comp x (Comp y (add xs ys))
02:58:00 <elliott> and voila
02:58:01 <elliott> interleave
02:58:05 <elliott> then I realised you could do this elegantly
02:58:13 <elliott> vPlus Base ys = ys
02:58:13 <elliott> vPlus (Comp x xs) ys = Comp x (vPlus ys xs)
02:58:22 <elliott> still, I'm not sure this is better than (++)
02:59:25 <elliott> oerjan: YOU GIVE INSUFFICIENT OPINIONS
02:59:36 <oerjan> PI ONIONS
03:00:30 <elliott> vTimes :: Val -> Val -> Val
03:00:30 <elliott> vTimes Base _ = Base
03:00:30 <elliott> vTimes _ Base = Base
03:00:30 <elliott> vTimes (Comp x xs) ys = go ys (vTimes xs ys)
03:00:30 <elliott> where go Base rs = rs
03:00:31 <elliott> go (Comp y ys) rs = Comp x (Comp y (go ys rs))
03:00:33 <elliott> what's this function I wonder
03:00:36 <elliott> oh wait that's the broken one
03:00:46 <elliott> vTimes :: Val -> Val -> Val
03:00:46 <elliott> vTimes Base _ = Base
03:00:46 <elliott> vTimes _ Base = Base
03:00:46 <elliott> vTimes (Comp x xs) ys = go ys (vTimes xs ys)
03:00:49 <elliott> where go Base rs = rs
03:00:49 <elliott> go (Comp y ys) rs = Comp (vAppend x y) (go ys rs)
03:00:50 <elliott> there
03:01:03 <elliott> hm that second clause is needless
03:01:38 <elliott> @check let f [] _ = []; f (x:xs) ys = go ys (f xs ys) where go [] rs = rs; go (y:ys) rs = (x++y):(go ys rs) in \xs ys -> length (f xs ys) == length xs * length ys
03:01:39 <lambdabot> "OK, passed 500 tests."
03:01:50 <elliott> @check let f [] _ = []; f (x:xs) ys = go ys (f xs ys) where go [] rs = rs; go (y:ys) rs = (x++y):(go ys rs) in \xs ys -> f xs ys == liftA2 (++) xs ys
03:01:53 <lambdabot> mueval-core: Time limit exceeded
03:01:56 <elliott> oerjan: wat
03:01:58 <elliott> @check let f [] _ = []; f (x:xs) ys = go ys (f xs ys) where go [] rs = rs; go (y:ys) rs = (x++y):(go ys rs) in \xs ys -> f xs ys == liftA2 (++) xs ys
03:02:01 <lambdabot> mueval-core: Time limit exceeded
03:02:03 <elliott> oerjan: what's the correct function
03:02:05 <elliott> liftM2 (++)?
03:02:08 <elliott> @check let f [] _ = []; f (x:xs) ys = go ys (f xs ys) where go [] rs = rs; go (y:ys) rs = (x++y):(go ys rs) in \xs ys -> f xs ys == liftM2 (++) xs ys
03:02:12 <lambdabot> mueval-core: Time limit exceeded
03:02:17 <oerjan> those are the same
03:02:24 <elliott> lambdabot: ok
03:02:28 <elliott> why is it exceeding? just bad luck?
03:02:41 <elliott> also, hmm, i kind of feel like + should be (++), just because vTimes uses (++) in a loop
03:03:43 <elliott> oerjan: now what's the list function where |f xs ys| == |xs|^|ys| :D
03:04:52 <oerjan> > (mapM . const) "abc" "def"
03:04:54 <lambdabot> ["aaa","aab","aac","aba","abb","abc","aca","acb","acc","baa","bab","bac","b...
03:05:28 <oerjan> > length $ (mapM . const) "abc" "def"
03:05:29 <lambdabot> 27
03:05:41 <elliott> oerjan: nice! now what's the actual algorithm to that...
03:05:58 <elliott> > (mapM . const) "abcd" "def"
03:05:59 <lambdabot> ["aaa","aab","aac","aad","aba","abb","abc","abd","aca","acb","acc","acd","a...
03:06:04 <elliott> > (mapM . const) "abc" "defg"
03:06:05 <lambdabot> ["aaaa","aaab","aaac","aaba","aabb","aabc","aaca","aacb","aacc","abaa","aba...
03:06:20 <elliott> > (mapM . const) [[],[],[]] [[],[],[],[]]
03:06:21 <oerjan> > length $ (mapM . const) "abc" "defg"
03:06:21 <lambdabot> [[[],[],[],[]],[[],[],[],[]],[[],[],[],[]],[[],[],[],[]],[[],[],[],[]],[[],...
03:06:23 <lambdabot> 81
03:06:28 <elliott> oh
03:06:31 <elliott> it introduces another level of nesting
03:06:39 <elliott> oerjan: what's the _flat_ function obeying that
03:06:44 <elliott> i.e. [a] -> [a] -> [a]
03:08:17 <elliott> oerjan ran away screaming
03:09:03 <oerjan> i'm just trying to think if there's anything better than just applying map (const []) to the result
03:09:07 <elliott> :D
03:09:22 <elliott> oerjan: yeah that wouldn't be good, i want functions that can theoretically munge arbitrary data around here
03:10:44 <oerjan> mapM intrinsically returns m ([a])
03:10:52 <oerjan> :t mapM
03:10:53 <lambdabot> forall a (m :: * -> *) b. (Monad m) => (a -> m b) -> [a] -> m [b]
03:11:20 <oerjan> @src mapM
03:11:21 <lambdabot> mapM f as = sequence (map f as)
03:12:10 <oerjan> and the use of sequence is essential to blowing up the size
03:12:30 <elliott> oerjan: sequence (concatMap f as)?
03:12:39 <oerjan> :t sequence
03:12:40 <lambdabot> forall (m :: * -> *) a. (Monad m) => [m a] -> m [a]
03:12:44 <elliott> :t \f as -> sequence (concatMap f as)
03:12:45 <lambdabot> forall a (m :: * -> *) a1. (Monad m) => (a -> [m a1]) -> [a] -> m [a1]
03:12:52 <oerjan> sequence also essentially returns m [a]
03:12:52 <elliott> not... reassuring
03:13:06 <elliott> oerjan: _essentially_? it *does* :)
03:13:27 <oerjan> i mean that's an essential part of how it works
03:13:41 <elliott> oerjan: right
03:13:48 <elliott> oerjan: maybe i'll ask #haskell
03:14:23 <elliott> :t replicate
03:14:24 <lambdabot> forall a. Int -> a -> [a]
03:14:51 <oerjan> you could apply map head to the result, none of the sublists can be empty
03:15:42 <oerjan> hm...
03:15:46 <oerjan> > sequence []
03:15:47 <lambdabot> No instance for (GHC.Show.Show (m [a]))
03:15:47 <lambdabot> arising from a use of `M50975851...
03:15:57 <oerjan> :t sequence []
03:15:57 <lambdabot> forall (m :: * -> *) a. (Monad m) => m [a]
03:16:06 <elliott> <lambdabot> arising from a use of `M50975851...
03:16:08 <elliott> :wat:
03:16:09 <oerjan> > sequence [] :: [[()]]
03:16:09 <lambdabot> [[]]
03:16:15 <oerjan> oh that one can
03:16:27 <elliott> <oerjan> you could apply map head to the result, none of the sublists can be empty
03:16:31 <elliott> i don't want to throw away information, dammit :)
03:16:42 <elliott> the |xs|^|ys| should seem like a happy side-effect to a general operation
03:17:00 <oerjan> well then it's a question of what kind of general operation _does_ look like that
03:17:06 <oerjan> if any
03:17:21 <elliott> oerjan: meanwhile, Cale scares me:
03:17:22 <elliott> <Cale> elliott: produce the list of all functions from xs to ys and enumerate their codomains in the order of xs?
03:17:22 <elliott> <Cale> er, ranges rather
03:17:27 <elliott> <Cale> err, no, that can't be right
03:17:38 <elliott> oerjan: well i never said it was EASY :D
03:17:57 <oerjan> i think Cale's suggestion would be rather more enormous
03:18:18 <oerjan> or wait
03:18:53 <oerjan> well it _is_ true each element is essentially such a function before you simplify it
03:19:52 <oerjan> the problem then is distilling each function down to just one element of xs and/or ys
03:21:02 <elliott> <monochrom> I am one of those who get mad for askers not accepting my answers. Q: "is it true 2+2=4?" A: "yes" Q:"I'm asking because I'm buying a $2 thing and another $2 thing online and I only want to pay $3" That gets me mad. Wishful denial of my factual answer.
03:21:15 <elliott> :wat:
03:22:43 <oerjan> well tell monochrom i think he looks at this too much in black and white
03:23:11 <elliott> :D
03:27:10 <elliott> <elliott> dafis: if i mention #esoteric again, in the future people will look back at #haskell logs, and think it was some place of great importance, what with the frequency it turns up in here. so I won't!
03:27:10 <elliott> <elliott> oops
03:27:13 <elliott> prepare for influx
03:27:28 -!- kfr has joined.
03:27:37 <kfr> Haha, awesome
03:27:52 <kfr> Is this where people gather to invent bizarre languages?
03:27:56 -!- elliott has set topic: THERE IS NOBODY HERE | http://esolangs.org/ | | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
03:27:58 <oerjan> elliott: this is horrible! and our topic is nearly accurate too!
03:28:01 <elliott> kfr: well. ostensibly.
03:28:07 <oerjan> elliott: thank you
03:28:12 <elliott> oerjan: you're welcome
03:28:17 <elliott> oerjan: do you want to just set +b for everyone?
03:28:23 <elliott> maybe they'll all go away!
03:28:26 <oerjan> we cannot have an accurate topic, that would be nontraditional
03:28:27 -!- variable has quit (Remote host closed the connection).
03:28:46 <oerjan> MAYBE
03:28:56 <elliott> at some point in time we will have assimilated the entire population of #haskell
03:28:56 <kfr> Wow, there are many people from #haskell in here
03:28:59 <elliott> isn't that our grand master plan?
03:29:00 <kfr> Coincidence? I think niot
03:29:03 <elliott> oh shit they're on to us!
03:29:13 <oerjan> elliott: WHY DIDN'T ANYONE TELL ME OF THIS PLAN
03:29:26 <elliott> haskellers may know oerjan as the person who wrote 7/8ths of the Haskell 98 report
03:29:30 <elliott> no exaggeration, not in the slightest
03:29:34 <elliott> please crowd around
03:29:53 <oerjan> probably not. although i _was_ the 6th most active person in #haskell for a while.
03:29:58 <oerjan> iirc.
03:30:09 <kfr> oerjan: Oh, did you really write parts of the 98 report?
03:30:16 <elliott> kfr: he fixed WHOLE TYPOS!!!
03:30:21 <oerjan> no, i sent typo corrections
03:30:23 <elliott> give him your utmost adoration!
03:30:36 <kfr> No, I hate Haskell
03:30:41 <elliott> haha
03:30:45 <elliott> oerjan: 6th most active? pfft, when that social graph was still being generated i was the gigantic centre of it
03:30:47 <oerjan> WHAT A SHIT LANGUAGE
03:30:51 <elliott> without ever talking about haskell!
03:30:56 <oerjan> >_>
03:31:10 <elliott> oerjan: i think we're giving everybody the impression that we're the only two who ever talk in here
03:31:21 <elliott> > text "but lambdabot talks too!"
03:31:22 <lambdabot> but lambdabot talks too!
03:31:41 <oerjan> it _is_ a bit silent at the moment
03:32:08 <elliott> sheesh neither #haskell nor oerjan have figured out the function yet
03:32:13 <elliott> i treat these sources as equals
03:32:35 <elliott> http://esolangs.org/wiki/ChalcraftGreen somebody less lazy than me should wikify this page someone made
03:33:10 <oerjan> elliott: EXACTLY my thought. except with "me" standing for oerjan.
03:33:21 <elliott> oerjan: "I", surely
03:33:40 <kfr> At first you start learning it and you can't reuse any of your previous programming knowledge. You write like 20 lines of Haskell and then you spend 40-60 minutes desperately trying to make it compile. Then at some point you develop Haskell cancer and you turn into a language fascist who doesn't use any other languages anymore. Eventually you stop writing programs, lost in abstract discourse over the newest zyganometamonadomorphism type classes etc.
03:33:42 <oerjan> elliott: i was referring to ChalcraftGreen
03:34:08 <elliott> oerjan: ah :P
03:34:12 <elliott> kfr: excuse me, we are the kind of people who skip straight to the zyganometamonadomorphism type classes.
03:34:34 <oerjan> the metadone morphisms, for the heavily addicted
03:34:55 <elliott> did we ever actually agree on a definition of turing completeness? :)
03:34:57 <kfr> Congratulations, at this stage you have completed your transformation from a once cheerful and productive hobby programmer to a bitter intellectual wreck.
03:35:17 <elliott> bitter, yes intellectual, yes wreck, yes, dunno if we were ever cheerful and productive
03:35:30 <kfr> Hahahaha
03:35:33 <elliott> a significant portion of us have sworn off programming altogether :D
03:36:02 -!- elliott has set topic: IVORY TOWER OF GRUMPY ACADEMIC ELITISTS | bring whisky or be kicked | http://esolangs.org/ | | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
03:36:18 <kfr> Ew, IRC logs
03:36:22 <kfr> Big brother is watching
03:36:31 <elliott> kfr: logged by the same people as #haskell!
03:36:37 <elliott> yes our insidious connections go WAY back!
03:36:38 <kfr> Terrible
03:36:49 <elliott> kfr: hey i'll have you know that logreading is a respected tradition here.
03:36:54 <elliott> we literally just pick logs at random and start reading. well I do.
03:37:08 <elliott> don't worry, google only finds us if you phrase your query well :D
03:37:10 <kfr> That sounds bizarre
03:37:20 <elliott> kfr: no it's great fun
03:37:28 <kfr> Well, I used to have centralised nicks which were easy to google
03:37:35 <kfr> Nowadays I use like 30 different nicks
03:37:42 <elliott> it's actually interesting reading material a lot of the time
03:37:44 <kfr> A different one for each service
03:37:44 <elliott> kfr: paranoid much? :)
03:37:44 <oerjan> ^ul ((0)(1)):^!S(~:^:S*a~^~*a*~:^):^ Try Underload instead!
03:37:45 <fungot> 011010011001011010010110011010011001011001101001011010011001011010010110011010010110100110010110011010011001011010010110011010011001011001101001011010011001011001101001100101101001011001101001011010011001011010010110011010011001011001101001011010011001011010010110011010010110100110010110011010011001011010010110011010010110 ...too much output!
03:37:58 <elliott> oerjan: oh my god what sequence is that printing
03:37:59 <kfr> elliott yes, I also use full system encryption with TrueCrypt etc
03:38:00 <elliott> it's so pretty
03:38:04 <oerjan> thue-morse
03:38:10 <elliott> kfr: ah. we'll get along like a house on fire.
03:38:32 <elliott> kfr: I wouldn't trust TrueCrypt mind you.
03:38:35 <oerjan> also mm, whisky
03:38:58 <oerjan> elliott: i'm just trying to give kfr a taste of what it's like on the rare occasions we are on topic
03:39:15 <elliott> oerjan: i think that's happened once.
03:39:17 <elliott> was it in 07?
03:39:26 <elliott> oerjan: HAVE YOU FIGURED OUT MY FUNCTION YET.
03:39:53 <oerjan> elliott: i've sort of given up a bit after Cale pointed out it's about functions
03:40:01 <oerjan> although one idea...
03:40:03 <elliott> oerjan: well it's like zfc isn't it
03:40:05 <elliott> |A^B| = |A|^|B|
03:40:17 <elliott> well not zfc, that applies pretty much anywhere
03:40:51 <oerjan> you could in fact use mapM to list all functions that way
03:41:11 <elliott> oerjan: gogogo
03:41:30 <oerjan> elliott: it's not going to help with your flattening desire
03:41:37 <elliott> i desire only flattening
03:41:48 <elliott> oerjan: well. hm.
03:42:01 <elliott> oerjan: perhaps we could use liftM2 (++) as (*) and do the rest from there.
03:42:07 <elliott> using my <IRRELEVANT> thing
03:42:16 <elliott> erm what's the recursive exponentiation algorithm again :D
03:42:32 <elliott> @src (**) Integer
03:42:32 <lambdabot> Source not found. There are some things that I just don't know.
03:42:33 <elliott> :t (**)
03:42:34 <lambdabot> forall a. (Floating a) => a -> a -> a
03:42:37 <elliott> @src (^) Integer
03:42:37 <lambdabot> Source not found. My brain just exploded
03:42:38 <elliott> hmph
03:43:17 <elliott> oerjan: you write the exp on Nats, i'm too lazy to
03:43:32 <oerjan> elliott: hm liftM2 (++) iterated you mean, hm...
03:43:50 <elliott> oerjan: right, replace Zero with Base and (Succ x) with (Comp <IRRELEVANT> x)
03:44:05 <elliott> oerjan: then you just have to change those comps into (Comp x xs), and figure out where the "x" and "y" go on the right-hand side :)
03:44:10 <elliott> i.e. which <IRRELEVANT>s they match up to there
03:44:19 <elliott> well that's the basic idea i'm using for transforming nat functions into these functions
03:44:47 <oerjan> well i'm trying to think if there's a simpler name for foldr1 (liftM2 (++)) or thereabouts
03:45:16 <elliott> :t foldr1 (liftM2 (++))
03:45:17 <lambdabot> forall a1 (m :: * -> *). (Monoid a1, Monad m) => [m a1] -> m a1
03:45:32 <elliott> > foldr1 (liftM2 (++)) [[1,2,3], [4,5,6]]
03:45:33 <lambdabot> Ambiguous type variable `a1' in the constraints:
03:45:33 <lambdabot> `GHC.Num.Num a1'
03:45:34 <lambdabot> a...
03:45:35 <oerjan> :t foldr (liftM2 (++)) [[]]
03:45:35 <lambdabot> forall a. [[[a]]] -> [[a]]
03:45:50 <elliott> > foldr (liftM2 (++)) [[]] [[1,2,3], [4,5,6]]
03:45:51 <lambdabot> No instance for (GHC.Num.Num [a])
03:45:51 <lambdabot> arising from a use of `e_12123456' at ...
03:46:04 <elliott> > foldr (liftM2 (++)) [[]] [[[1,2,3], [4,5,6]], [[7, 8, 9], [10, 11, 12]]]
03:46:06 <lambdabot> [[1,2,3,7,8,9],[1,2,3,10,11,12],[4,5,6,7,8,9],[4,5,6,10,11,12]]
03:46:17 <elliott> > length $ foldr (liftM2 (++)) [[]] [[[1,2,3], [4,5,6]], [[7, 8, 9], [10, 11, 12]]]
03:46:18 <lambdabot> 4
03:46:31 <elliott> > length $ foldr (liftM2 (++)) [[]] [ [[],[]], [[],[],[]] ]
03:46:33 <lambdabot> 6
03:46:34 <elliott> that should be 2^3
03:46:40 <elliott> nope
03:46:42 <elliott> oerjan: fail
03:47:12 <oerjan> elliott: i intend it only as a building block, sheesh
03:47:15 <elliott> oerjan: :D
03:47:24 <elliott> oerjan: seriously though, write out recursive exponentiation for me, i'm insanely lazy
03:47:48 <elliott> exp n Z = n; exp n (S Z) = n; exp n (S (S m)) = n * exp n m
03:47:50 <elliott> you're WELCOME
03:48:05 <elliott> *= Z
03:48:12 <oerjan> the ^ definition uses binary representation anyway
03:48:27 <elliott> oerjan: eh?
03:48:40 <oerjan> :t (^)
03:48:41 <lambdabot> forall a b. (Num a, Integral b) => a -> b -> a
03:48:43 <elliott> exp n Z = Z
03:48:43 <elliott> exp n (S Z) = n
03:48:44 <elliott> exp n (Comp irr (Comp irr' m)) = vTimes n (exp n m)
03:48:47 <oerjan> for the b there
03:48:48 <elliott> hmm that (S Z) is problematic
03:49:08 <elliott> exp n Base = Z
03:49:08 <elliott> exp n (Comp irr Z) = n
03:49:08 <elliott> exp n (Comp irr (Comp irr' m)) = vTimes n (exp n m)
03:49:13 <elliott> not at all clear what to do here :D
03:49:46 <elliott> exp _ Base = Base
03:49:46 <elliott> exp xs (Comp irr Base) = xs
03:49:46 <elliott> exp xs (Comp irr (Comp irr' ys)) = vTimes xs (exp xs ys)
03:49:55 <pikhq> ... Wait wait wait... Someone is claiming that most Brits find peanut butter "revolting".
03:50:07 <pikhq> elliott: Is there any truth to this bullshit?
03:50:07 <elliott> oerjan: maybe "vTimes xs (Comp irr (Comp irr' (exp xs ys)))"?
03:50:14 <elliott> but then i'm not sure that would produce the correct lengths.
03:50:16 <elliott> pikhq: i don't like it
03:50:30 <pikhq> elliott: LIES AND DECEIT.
03:51:12 <oerjan> :t \a b -> foldr (liftM2 (++)) [[]] $ map (const a) b
03:51:13 <lambdabot> forall a a1. [[a]] -> [a1] -> [[a]]
03:51:55 <oerjan> > (\a b -> foldr (liftM2 (++)) [[]] $ map (const a) b) [[],[],[]] [[],[]]
03:51:57 <lambdabot> [[],[],[],[],[],[],[],[],[]]
03:52:22 <elliott> *Main> vExp three two
03:52:22 <elliott> Base
03:52:27 <elliott> THAT'S NOT QUITE RIGHT
03:53:03 <elliott> *Main> :load "/home/elliott/Code/meddle/meddle.hs"
03:53:03 <elliott> [1 of 1] Compiling Main ( /home/elliott/Code/meddle/meddle.hs, interpreted )
03:53:03 <elliott> Ok, modules loaded: Main.
03:53:03 <elliott> *Main> vExp three two
03:53:03 <elliott> Comp Base (Comp Base (Comp Base (Comp Base (Comp Base (Comp Base Base)))))
03:53:03 <elliott> *Main> len $ vExp three two
03:53:05 <elliott> 6
03:53:07 <elliott> darn
03:53:09 <pikhq> What's not quite right is disliking peanut butter but liking Marmite. Seriously, WTF.
03:53:18 <oerjan> elliott: exp n Z = S Z, surely
03:53:25 <elliott> oerjan: facepalm, yes indeed
03:53:36 <elliott> so Comp Base Base
03:53:41 <elliott> except that seems a bit ungeneral...
03:53:43 <elliott> oerjan: carry on :P
03:53:50 <elliott> *Main> len $ vExp three two
03:53:50 <elliott> 9
03:53:56 <elliott> *Main> len $ vExp three three
03:53:56 <elliott> 18
03:54:00 <elliott> buggre.
03:54:27 <elliott> oerjan: any luck? :p
03:55:02 <oerjan> what is that Comp thing again
03:55:40 <elliott> oerjan: Cons
03:55:44 <elliott> data Val = Base | Comp Val Val deriving (Show)
03:55:55 <elliott> oerjan: numerals are
03:55:57 <elliott> zero = Base
03:55:59 <elliott> succ x = Comp Base x
03:56:53 <oerjan> ok so exp n (Comp irr x) = vTimes n (exp n x)
03:57:01 <elliott> oerjan: *ahem*
03:57:05 <elliott> you are not allowed to leave irrs lying around
03:57:13 <elliott> oerjan: remember, no throwing away information :p
03:57:28 <oerjan> that makes this _very_ awkward
03:57:30 <elliott> oerjan: the irr is just an easy way to turn simple recursive functions on nats into those on vals
03:57:32 <elliott> for instance
03:57:47 <elliott> add Zero y = y; add (Succ x) y = Succ (add x y)
03:57:47 <elliott> ->
03:57:49 <oerjan> since the obvious thing to do _is_ to throw them away and multiply copies of n
03:58:12 <elliott> add Base ys = ys; add (Comp <irr> xs) ys = Comp <irr> (add xs ys)
03:58:27 <elliott> add Base ys = ys; add (Comp x xs) ys = Comp x (add xs ys)
03:58:38 <elliott> oerjan: is it, from a list point of view?
03:58:45 <elliott> oerjan: i don't really see any list functions ignoring their data
03:59:46 <oerjan> oh it's easy to include the information if you don't insist on a^b containing elements from a and b _on the top level_
03:59:57 <elliott> oerjan: :D
04:00:04 <elliott> oerjan: but then (num^num) wouldn't be a num
04:00:08 <elliott> because numbers are lists of []s
04:00:10 <oerjan> just do what Cale said
04:00:13 <elliott> oerjan: but then (num^num) wouldn't be a num
04:00:14 <elliott> because numbers are lists of []s
04:00:17 <elliott> thus the flatness requirement
04:00:19 <oerjan> enumerate the functions
04:00:33 <elliott> oerjan: isn't that going to be hideously impractical...
04:00:49 <oerjan> sure if you look inside them...
04:01:48 <elliott> oerjan: hm i don't quite understand then
04:03:17 <elliott> oerjan: THAT WAS YOUR CUE TO EXPLAIN
04:03:23 <oerjan> well in order to define exponentiation of a^b using multiplication, you generate b lists of the same length as a and then multiply them. it's easy to do this if you don't need the information from b inside those lists (just use a itself)
04:03:43 <oerjan> otherwise we need some other way to construct lists of length |a|
04:04:00 <oerjan> *|b| lists
04:04:20 <elliott> oerjan: by mixing together a and b somehow?
04:04:31 <elliott> oerjan: but what was that enumerate the functions thing?
04:04:36 <oerjan> yeah. hm...
04:05:02 <oerjan> elliott: you can describe a function as a list of tuples
04:05:13 <elliott> oerjan: no shit sherlock
04:05:22 <elliott> oerjan: i just mean how would that be used
04:05:36 <elliott> oerjan: flattening [(a,b),(c,d),...] into [a,b,c,d,...] won't work, since that doubles the length
04:05:55 <oerjan> elliott: it's just the "natural" (in the category sense, probably) way of constructing a^b as a set
04:06:01 <elliott> oh certainly
04:06:32 <oerjan> however hm let us _try_ to include information from b in the a copy lists.
04:06:34 <elliott> oerjan: hmm. how many times can we give the entire contents of b with |b| lists of length |a|?
04:06:37 <elliott> well, |a| times obviously
04:06:49 <elliott> how many times can we give the entire contents of a with |b| lists of length |a|?
04:06:50 <elliott> |b| times
04:06:56 <oerjan> since there are |b| of them, each can be based on a single element of b
04:07:00 <elliott> how many times can we give the entire contents of both a and b with |b| lists of length |a|?
04:07:06 <oerjan> elliott: SHUT UP I'M THINKING
04:07:12 <elliott> OKAY
04:07:22 <elliott> well the answer is... we need to store |a|+|b| in |a|*|b|
04:07:33 <elliott> so ab/(a+b)
04:07:50 <elliott> = |a| - (|a|^2)/(|a|+|b|) thx W^A
04:07:52 <elliott> *W|A
04:07:59 <elliott> so we need to pack the list that many times...heh
04:08:02 <oerjan> let x in b, then we want to combine x with a. now x is ostensibly of the same type as a's elements
04:08:05 <elliott> i'll let you return to your thinking, this is going nowhere
04:08:10 <elliott> oerjan: type is irrelevant, yeah
04:08:19 <elliott> everything is of type T = [T]
04:08:23 <oerjan> so we can do map (x++) a
04:08:39 <oerjan> elliott: TYPES ARE IMPORTANT FOR INTUITION
04:08:41 <elliott> OKAY
04:08:44 <elliott> INTUIT
04:09:29 <oerjan> or (++x) more, i think
04:09:47 <elliott> note that for the numeric case x = []
04:10:15 <oerjan> yes, that's the main case which needs to work
04:10:30 <elliott> yes
04:10:40 <elliott> i think you're on to something, by jove
04:11:07 <oerjan> \a b -> map (\x -> map (++x) a) b
04:11:14 <elliott> :t \a b -> map (\x -> map (++x) a) b
04:11:15 <oerjan> :t \a b -> map (\x -> map (++x) a) b
04:11:15 <lambdabot> forall a. (Monoid a) => [a] -> [a] -> [[a]]
04:11:16 <lambdabot> forall a. (Monoid a) => [a] -> [a] -> [[a]]
04:11:18 <elliott> :D
04:11:20 <elliott> Monoid a? heh
04:11:22 <elliott> :t map
04:11:23 <lambdabot> forall a b. (a -> b) -> [a] -> [b]
04:11:24 <elliott> :t (++)
04:11:25 <lambdabot> forall m. (Monoid m) => m -> m -> m
04:11:28 <elliott> DAMMIT, CALESKELL
04:11:35 <elliott> ok so that's [[a]] -> [[a]] -> [[[a]]] in _real land_
04:11:52 <elliott> > length $ (\a b -> map (\x -> map (++x) a) b) [[],[],[]] [[],[],[]]
04:11:54 <lambdabot> 3
04:11:59 <elliott> > length $ (\a b -> concatMap (\x -> map (++x) a) b) [[],[],[]] [[],[],[]]
04:12:00 <lambdabot> 9
04:12:05 <elliott> oerjan: erm...
04:12:07 <elliott> > length $ (\a b -> concatMap (\x -> map (++x) a) b) [[],[],[]] [[],[],[],[]]
04:12:08 <lambdabot> 12
04:12:26 <oerjan> ...the part where your brain doesn't get that WE'RE STILL BUILDING BLOCKS.
04:13:10 <oerjan> and we do _not_ want concatMap there, that list contains elements to be multiplied together
04:13:38 <oerjan> :t \a b -> foldr (liftM2 (++)) [[]] $ map (\x -> map (++x) a) b
04:13:38 <lambdabot> forall a. [[a]] -> [[a]] -> [[a]]
04:13:46 <elliott> oerjan: i'm just trolling you :)
04:13:47 <oerjan> TRY THAT ONE
04:14:02 <elliott> > length $ (\a b -> foldr (liftM2 (++)) [[]] $ map (\x -> map (++x) a) b) [[],[],[]] [[],[],[]]
04:14:04 <lambdabot> 27
04:14:11 <elliott> :D
04:14:21 <elliott> > length $ (\a b -> foldr (liftM2 (++)) [[]] $ map (\x -> map (++x) a) b) [[1,2,3],[4,5,6],[7,8,9]] [[10,11,12],[13,14,15],[16,17,18]]
04:14:23 <lambdabot> 27
04:14:27 <elliott> > (\a b -> foldr (liftM2 (++)) [[]] $ map (\x -> map (++x) a) b) [[1,2,3],[4,5,6],[7,8,9]] [[10,11,12],[13,14,15],[16,17,18]]
04:14:29 <lambdabot> [[1,2,3,10,11,12,1,2,3,13,14,15,1,2,3,16,17,18],[1,2,3,10,11,12,1,2,3,13,14...
04:14:40 <elliott> oerjan: i'm just going to assume it has all the information there :P
04:14:47 <elliott> oerjan: so, er, is this option actually useful for _anything_
04:15:36 <oerjan> well unless a is empty, then there isn't much we can do to keep the information
04:16:52 <elliott> oerjan: well yes
04:17:01 <oerjan> :t \a b -> foldr (liftM2 (++)) [mempty] $ map (\x -> map (++x) a) b
04:17:02 <lambdabot> forall a. (Monoid a) => [a] -> [a] -> [a]
04:17:07 <elliott> lol
04:18:48 <oerjan> :t \a b -> foldr (liftM2 (++)) [mempty] $ [y++x | x <- b, y <- a]]
04:18:49 <lambdabot> parse error on input `]'
04:18:52 <oerjan> oops
04:18:56 <oerjan> :t \a b -> foldr (liftM2 (++)) [mempty] $ [y++x | x <- b, y <- a]
04:18:57 <lambdabot> forall a1. (Monoid a1) => [[a1]] -> [[a1]] -> [a1]
04:19:10 <oerjan> er no
04:19:11 <oerjan> oh
04:19:27 <elliott> ?]
04:19:28 <lambdabot> Maybe you meant: . ? @ v
04:19:29 <elliott> *?
04:19:37 <oerjan> :t \a b -> foldr (liftM2 (++)) [mempty] $ [[y++x | y <- a]| x <- b]
04:19:37 <lambdabot> forall a1. (Monoid a1) => [a1] -> [a1] -> [a1]
04:20:52 <oerjan> :t concat
04:20:53 <lambdabot> forall a. [[a]] -> [a]
04:21:02 <oerjan> :t mappend
04:21:03 <lambdabot> forall a. (Monoid a) => a -> a -> a
04:21:07 <elliott> > (\a b -> foldr (liftM2 (++)) [[]] $ map (\x -> map (++x) a) b) [[1,2,3],[4,5,6],[7,8,9]] [[]]
04:21:09 <lambdabot> [[1,2,3],[4,5,6],[7,8,9]]
04:21:10 <oerjan> :t mconcat
04:21:11 <lambdabot> forall a. (Monoid a) => [a] -> a
04:21:12 <elliott> so ^1 = id. good
04:21:14 <elliott> > (\a b -> foldr (liftM2 (++)) [[]] $ map (\x -> map (++x) a) b) [[1,2,3],[4,5,6],[7,8,9]] []
04:21:16 <lambdabot> [[]]
04:21:21 <elliott> ^0 = 1. good.
04:21:29 <elliott> > (\a b -> foldr (liftM2 (++)) [[]] $ map (\x -> map (++x) a) b) [[1,2,3],[4,5,6],[7,8]] [[]]
04:21:30 <lambdabot> [[1,2,3],[4,5,6],[7,8]]
04:21:34 <elliott> > (\a b -> foldr (liftM2 (++)) [[]] $ map (\x -> map (++x) a) b) [[1,2,3],[4,5,6],[7,8]] [[],[]]
04:21:35 <lambdabot> [[1,2,3,1,2,3],[1,2,3,4,5,6],[1,2,3,7,8],[4,5,6,1,2,3],[4,5,6,4,5,6],[4,5,6...
04:21:41 <elliott> oerjan: yikes, differing lengths?
04:21:46 <elliott> i wonder how they behave
04:22:06 <oerjan> you started out with differing lengths
04:22:37 <oerjan> (missing 9)
04:22:59 <elliott> oerjan: i know that
04:23:02 <elliott> it was intentional :)
04:23:06 <elliott> oerjan: ok so is this function actually useful for shit...
04:23:15 <elliott> > (\a b -> foldr (liftM2 (++)) [[]] $ map (\x -> map (++x) a) b) [[1], [2,3]] [[4,5,6],[]]
04:23:17 <lambdabot> [[1,4,5,6,1],[1,4,5,6,2,3],[2,3,4,5,6,1],[2,3,4,5,6,2,3]]
04:23:27 <elliott> it doesn't look useful at all :D
04:23:39 <elliott> but it does nicely satisfy the properties, now oerjan, how about SUBTRACTION
04:23:43 <elliott> (jokin'!)
04:24:49 <elliott> i'm still not sure whether to use interleave or append for addition
04:25:05 <elliott> my current addition function corresponds to "add Zero y = y; add (Succ x) y = Succ (add y x)"
04:25:24 <elliott> but append corresponds to "add Zero y = y; add (Succ x) y = Succ (add x y)", you can see my problem here :)
04:25:31 <elliott> well
04:25:39 <elliott> i suppose having + be concatenation on lists is something people consider "useful".
04:25:45 <oerjan> @check \l -> foldr (liftM2 (++)) [mempty] == map mconcat (sequence l)
04:25:46 <lambdabot> Couldn't match expected type `[[[a]]] -> [[a]]'
04:25:49 <oerjan> er
04:26:04 <oerjan> oh
04:26:09 <oerjan> @check \l -> foldr (liftM2 (++)) [mempty] l == map mconcat (sequence l)
04:26:14 <lambdabot> mueval-core: Time limit exceeded
04:26:17 <elliott> oerjan: so does (\a b -> foldr (liftM2 (++)) [[]] $ map (\x -> map (++x) a) b) have a simple recursive representation? i doubt it...
04:26:23 <oerjan> well at least it typed
04:26:29 <elliott> ha
04:26:32 <oerjan> :t map mconcat . sequence
04:26:37 <lambdabot> forall a. (Monoid a) => [[a]] -> [a]
04:26:41 <elliott> "it typechecked, the program works, time to push the build into production"
04:26:46 <oerjan> :t foldr (liftM2 (++)) [mempty]
04:26:47 <lambdabot> forall a1. (Monoid a1) => [[a1]] -> [a1]
04:26:56 -!- yorick has joined.
04:27:37 <elliott> <elliott> oerjan: so does (\a b -> foldr (liftM2 (++)) [[]] $ map (\x -> map (++x) a) b) have a simple recursive representation? i doubt it...
04:27:39 <elliott> actually i think it does
04:27:55 <elliott> foldr is just a loop through the list, liftM2 (++) is just my vTimes, and that map can be done at each recursive step, I think
04:27:56 <elliott> I _think_
04:27:58 <elliott> or wait, can it?
04:29:10 <elliott> goodnight
04:30:02 <oerjan> probably
04:33:49 -!- elliott has quit (Ping timeout: 240 seconds).
04:59:31 <Mathnerd314> random q: is it weird if you read blog posts entitled "I suck" and start agreeing with them?
05:00:35 <Mathnerd314> like, "this person totally sucks; they even wrote a blog post about how badly they suck"
05:09:24 <oerjan> hey, _i_ suck so badly i cannot even write blog posts!
05:12:30 -!- Sgeo has quit (Read error: Connection reset by peer).
05:16:49 <Mathnerd314> alright, so it's the blog that's weird and not necessarily me
05:21:43 -!- zzo38 has joined.
05:22:21 <zzo38> How to bring whisky on the IRC?
05:23:36 <oerjan> DON'T ASK ME, I DIDN'T MAKE THE POLICY
05:25:07 <pikhq> konnhįȳûtaniarutoki,uīsukîwomotu.sìȳa',uīsukîtoIRCsurune.
05:25:30 <pikhq> "Translation": No, I don't feel like giving you a useful answer.
05:25:31 <pikhq> :P
05:26:18 <zzo38> Why don't you write it properly in kana (and/or kanji)? That is more efficient to read than the romaji.
05:26:28 <pikhq> zzo38: Because I don't feel like giving you a useful answer.
05:26:41 <zzo38> pikhq: O, that's why. Now I know why.
05:26:49 <pikhq> But if you *insist*...
05:27:25 <pikhq> コンピュータにあるとき、ウィスキーを持つ。じゃっ、ウィスキーとIRCするね。
05:28:14 <pikhq> "When you're at your computer, have whisky. There, you're now IRCing with whisky."
05:28:37 <pikhq> ...
05:28:43 <pikhq> s/とき/時/
05:30:38 <zzo38> That's better.
05:39:25 -!- Mathnerd314 has quit (Remote host closed the connection).
05:49:41 <pikhq> ...
05:49:45 <pikhq> s/ある/いる/
06:13:31 -!- Lymia has joined.
06:15:09 -!- Wamanuz has quit (Remote host closed the connection).
06:15:26 <Lymia> Can somebody here patch the FukYorBrane reference implementation?
06:15:36 <Gregor> I should certainly hope I could.
06:16:00 <Lymia> What's up with line 580
06:16:04 <Lymia> It's causing segfaults.
06:16:15 <Lymia> It looks like [procowner] should be [procowner-1]
06:18:09 <Gregor> WOW it's been a long time since I've looked at this code :P
06:19:21 <Gregor> Yup, that should most assuredly be procowner-1 >_>
06:19:22 <Lymia> :V
06:20:16 <Gregor> That bug is now five years old X-D
06:20:34 <Lymia> And somehow unnoticed.
06:20:36 <Lymia> ><
06:20:52 <kfr> Are research languages tolerated in here or do they have to be sufficiently whack/bizarre?
06:21:08 <Gregor> kfr: Usually tolerated, unless they're too normal :P
06:21:13 <kfr> Are practical languages frowned upon in here?
06:21:25 <zzo38> kfr: Try. Write what you want to write and then we can see.
06:21:32 <kfr> Haha.
06:21:35 <Gregor> kfr: Depends on the definition of "practical" of whoever's in here :P
06:21:47 <kfr> I wanted to make a self hosting compiler for fun
06:21:50 <Lymia> I assume a normal language with convoluted enoguh syntax will do.
06:21:55 <kfr> Wit IA-32/AMD64 cod generation
06:22:05 <kfr> Supporting both Windows PE and Linux ELF
06:22:09 <Lymia> enough*
06:22:14 <kfr> With*, code*
06:22:15 <Lymia> kfr, and provide no other documentation.
06:22:16 <Lymia> ;)
06:22:21 <kfr> Lymia lol
06:22:39 <Lymia> Go read the source, or go read the binary.
06:22:40 <Lymia> :>
06:22:57 <kfr> I wonder how short you can make this without really writing any larger parts in ASM
06:23:28 <zzo38> kfr: What is it that you are making?
06:23:35 <Gregor> !fyb failolz +[]
06:23:37 <kfr> zzo38 just a joke really
06:23:45 <kfr> If I wanted to make a serious language I'd use LLVM
06:23:52 <kfr> And no self hosting
06:24:28 <EgoBot> Score for Gregor_failolz: 1.9
06:24:45 <kfr> Gregor what was that?
06:24:46 <Gregor> !help fyb
06:24:46 <EgoBot> Sorry, I have no help for fyb!
06:24:49 <zzo38> kfr: OK. But still, what is it?
06:24:52 <zzo38> !scoreboard
06:24:55 <Gregor> kfr: Rerunning the FYB hill with the bug fixed >_>
06:25:01 <Gregor> !fyb
06:25:01 <EgoBot> Use: !fyb <program name> <program>
06:25:08 <Gregor> Bleh, doesn't announce the scoreboard location :P
06:25:09 <Gregor> !bfjoust
06:25:10 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
06:25:15 <Lymia> So.
06:25:18 <kfr> zzo38: I haven't decided on any specifics really, I just wanted to make a self hosting compiler in some joke language at some point
06:25:20 <Lymia> If I understand what this bug means correctly.
06:25:31 <Lymia> * in a subprocess only works if you're the first program, and crashes otherwise.
06:25:31 <Gregor> http://codu.org/eso/fyb/report.txt Whew, logicex-2 still remains supreme.
06:25:39 <Lymia> And farthermore, it looks for the ; in the ENEMY program.
06:25:43 <Gregor> Lymia: 'til it was now fixed X-P
06:26:04 <Gregor> 's not a popular command :P
06:26:05 <Lymia> Anywhere to submit larger programs?
06:26:27 * Gregor tries to recall if !fyb can use URLs ...
06:26:39 <Lymia> !fyb test http://example.com
06:26:42 <EgoBot> Score for Lymia_test: 0.0
06:27:09 -!- Wamanuz has joined.
06:27:13 <zzo38> kfr: Well, such things are things that are sometimes related to esolangs. There is a "Joke language list" in the wiki, which you can view. However, "joke language" is mostly like unusable things, things that don't work, and so on; most esolangs are not considered "joke language" even if it is partially created as a joke.
06:27:30 <Gregor> Lymia: http://codu.org/eso/fyb/in_egobot/Lymia_test.fyb Yup, worked
06:27:51 <Lymia> HTML makes a horrible fighter. :V
06:27:53 <kfr> Well it wasn't supposed to be lolcode or anything like that
06:28:02 <Gregor> !fyb
06:28:03 <EgoBot> Use: !fyb <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/fyb/
06:28:17 <zzo38> kfr: Review the wiki and then you can decide whether or not it belongs.
06:28:22 <Gregor> Lymia: Can you defeat logicex-2? ^^
06:28:27 <Lymia> Yes.
06:28:29 <Lymia> One sec.
06:28:32 <Gregor> D-8
06:29:25 <Lymia> !fyb evil http://lymia.x10.bz/evil.fyb
06:29:58 <EgoBot> Score for Lymia_evil: 71.3
06:30:30 <Lymia> I think it's quite clear how it works.
06:30:30 <Lymia> :>
06:30:35 <kfr> zzo38 hmm those look quite different from what I had in mind
06:30:39 <Gregor> Oh noooooooooooooooooooooooose
06:30:43 <Lymia> (I expected it to lose more agienst other bots actually)
06:30:52 <zzo38> kfr: Review the non-joke list, too.
06:30:52 <Gregor> This is the first time in nearly five years that logicex-2 has gotten a score less than 100.0 X-P
06:30:57 <Lymia> Gregor, heh.
06:31:03 <kfr> zzo38 but I was considering using tons of UTF-8 symbols
06:31:04 <Lymia> The bot destroys every ! command in LogicEx
06:31:09 <kfr> To catch the eye
06:31:10 <Gregor> Pff, time for logicex-3.
06:31:12 <Lymia> Then goes bomb every single command.
06:31:15 <kfr> APL calls!
06:31:25 <Lymia> It's explicitly targeted at logicex.
06:31:32 <Gregor> Ahhhhh, I see :P
06:32:05 <Lymia> And it's very successful at doing just what it's meant to do.
06:32:06 <zzo38> kfr: You can consider using tons of UTF-8 symbols, then. Ideas like that are on the wiki, but nothing even partially complete. You could make one with better descriptions and a more complete one than just the idea.
06:32:06 <Lymia> :>
06:32:48 <Gregor> Lymia: It does pretty friggin' well otherwise, too (simply because running like hell and bombing randomly isn't a bad strategy)
06:33:05 <Lymia> Gregor, also, the fact that @ also sets the data pointer to the current instruction pointer isn't documented anywhere but the code.
06:33:19 <Gregor> Sweet 8-D
06:34:17 <Lymia> You can fix logicex by adding a single nop somewhere.
06:34:17 <Lymia> :v
06:34:21 <zzo38> I noticed the git repository commitdiff log has "author" and "committer" fields, both are the same. Is there a difference?
06:34:42 <Gregor> Lymia: Well, FYB is effectively "maintained" as part of EgoBot now, so you can get the fixed code in http://codu.org/projects/egobot/ . I will eventually retaliate, but for the time being I have other stuff to do :P
06:35:08 <Lymia> zzo38, you can pull from an external server that you don't own.
06:35:11 <Lymia> Including other's commits.
06:35:25 <Lymia> i.e. it comes into play when you pull from a fork
06:35:26 <zzo38> Lymia: OK, thanks.
06:35:39 <zzo38> I understand now.
06:36:18 <Gregor> If they're different for a revision that introduces a bug, you know both who to blame for /writing/ a bug, and who to blame for /approving/ the bug ^^
06:38:01 <zzo38> Gregor: In my case it is a non-forked repository that I am the only one with write-access, so it makes no difference. However, there is another repository (the "Extra" repository) which I am willing to add other users to the access list if they can help with it.
06:38:32 <zzo38> Does that make such a thing possible sometimes?
06:39:57 <kfr> I was thinking about making a functional language with only one type, integer
06:40:07 <kfr> Wait, I need lists obviously
06:40:13 <kfr> But they would be arrays really, I won't lie
06:41:20 <zzo38> kfr: Then make up ideas if you want to. But how can you have functional language if there is no function type? Maybe by making just lists of numbers to represent a function?
06:41:41 <kfr> zzo38 it's not really functional and not homoiconic either
06:41:54 <kfr> But you don't have sequential statements
06:42:09 <zzo38> kfr: OK, well, make it in whatever way you want to make it.
06:42:35 <oerjan> hey all you need is gödel numbers
06:42:54 <kfr> lol
06:42:59 <zzo38> oerjan: Yes, I think so.
06:43:32 <zzo38> (In fact that was also one of my idea in some programming language idea I had, where anything in square brackets gets converted to its godel number)
06:45:31 <zzo38> Do you have computer game ideas? I have had many different ideas for computer games (and other games)
06:45:38 <kfr> Then a string would just be an array of numerical codepoints haha
06:45:53 <kfr> This is starting to sound like emacs Lisp :[
06:46:21 <zzo38> kfr: There are some programming languages that do just treat strings as arrays of numerical codepoints.
06:46:28 <oerjan> i recall we discussed something like that, converting data types bijectively to numbers. although it had a bit of tendency to blow up when given long lists.
06:46:57 -!- Zuu_ has joined.
06:47:00 <zzo38> You could even represent the lists as a natural number, too.
06:47:00 -!- Zuu has quit (Read error: Connection reset by peer).
06:47:21 <oerjan> well of course that was the idea, and that encoding blew up
06:47:34 <kfr> I don't really need signed integers for a primitive self hosting compiler I think
06:47:41 <zzo38> (dc can use a number as a string, and treats the number as base 256 and then sends the string to output)
06:48:05 <oerjan> because it encoded conses, and did not balance very well when the tails got deep
06:48:23 <Lymia> Gregor, you have another segfault somewhere.
06:48:31 <oerjan> i think it was encoding brainfuck
06:48:40 <Gregor> Lymia: YESSSSSSSSSSSSSSSSSSS
06:49:01 -!- deaters has joined.
06:49:03 <zzo38> There are a few possible ways to encode multiple natural numbers in one number, one way is the INTERCAL interleave operator (but with unbounded size).
06:49:24 <oerjan> zzo38: hm yes that was suggested too
06:50:21 <Lymia> Have you considered rewriting this in a more memory safe language?
06:50:21 <Lymia> :v
06:50:37 <Gregor> Nope
06:50:49 <kfr> I'd write the first compiler in Haskell
06:50:50 <Gregor> Bear in mind that I haven't looked at this code in years :P
06:50:52 <kfr> Because I hate myself
06:51:27 <Lymia> if (!progSpent[procnum][*pptr]) {
06:51:32 <Lymia> You have a segfault in there.
06:54:44 <Lymia> Gregor, screw this. Quick question.
06:54:53 <Lymia> Every thread executes one opcode every tick, right?
06:57:51 <zzo38> Is it sometimes strategically useful to sacrifice a wicket (without declaring)?
07:03:38 -!- deaters has quit (Quit: deaters).
07:22:14 <zzo38> Read computer game idea: gopher://zzo38computer.cjb.net/0textfile/miscellaneous/computergameidea
07:24:37 <zzo38> Have you played the game called "Tetanus on Drugs" or "Lockjaw: The OverDose"?
07:28:38 <fizzie> MATLAB strings are vectors of character codes.
07:29:10 <zzo38> fizzie: I didn't know that. Now I know. There are also other programming languages where strings are treated as list of character codes, too.
07:29:56 <fizzie> The data type for the vector is set to "char", though, which makes many more mathematical operators not act on them. I think in earlier versions it wasn't so strict about types, though.
07:30:46 <fizzie> But you can still do, for example,
07:30:49 <fizzie> >> norm(floor('hello'))
07:30:49 <fizzie> ans =
07:30:49 <fizzie> 238.0462
07:31:09 <fizzie> The "floor" operator doesn't care that they're chars, and after flooring it's just a numeric vector.
07:31:22 <fizzie> s/operator/function/ I guess.
07:33:10 <fizzie> Or you can sum them, that also throws away the flag that it's a string:
07:33:12 <fizzie> >> 'you' + 'me!'
07:33:12 <fizzie> ans =
07:33:12 <fizzie> 230 212 150
07:33:12 <fizzie> >> norm('you' + 'me!')
07:33:12 <fizzie> ans =
07:33:12 <fizzie> 346.9063
07:33:21 <oerjan> > sum.map((^2).fromEnum)$"hello"
07:33:24 <lambdabot> 56666
07:33:33 <oerjan> hm...
07:33:40 <fizzie> (I used "norm" there just because it was the first thing that came to my mind that didn't really make that much sense for a string.)
07:33:54 <fizzie> (It's the Euclidean norm by default.)
07:34:11 <oerjan> > sqrt.sum.map((^2).fromEnum)$"hello"
07:34:12 <lambdabot> No instance for (GHC.Float.Floating GHC.Types.Int)
07:34:12 <lambdabot> arising from a use of...
07:34:25 <oerjan> > sqrt.sum.map((^2).fromIntegral.fromEnum)$"hello"
07:34:26 <lambdabot> 238.04621400055913
07:34:31 <oerjan> sheesh
07:35:35 <fizzie> >> sum('it up')
07:35:35 <fizzie> ans =
07:35:35 <fizzie> 482
07:35:43 <fizzie> Yeah, it's not that many things that care about types.
07:36:06 <zzo38> Can it be done the other way around, to change a list of numbers to a string?
07:36:36 <fizzie> Yes. Well, in the sense that you can just pass a list of numbers pretty much wherever a string is expected. Though sometimes you need to put a char() around it so it gets the correct type.
07:36:56 -!- asiekierka has joined.
07:37:02 <zzo38> fizzie: Yes that is what I meant. OK.
07:37:19 <fizzie> >> disp(100:110)
07:37:19 <fizzie> 100 101 102 103 104 105 106 107 108 109 110
07:37:19 <fizzie> >> disp(char(100:110))
07:37:19 <fizzie> defghijklmn
07:38:44 <zzo38> OK
07:39:38 <zzo38> Even in C, a string is like an array of char.
07:40:13 <zzo38> (Except, that it is null-terminated; arrays in C you cannot find the length easily because it is not stored with the array)
07:40:27 <zzo38> (unless you put it there)
07:42:12 <fizzie> Whereas in TCL, lists are just strings.
07:42:28 <zzo38> And is useful; you can even write something like *strchr(s,':')=0; if you want to cut off a string.
07:42:38 <fizzie> % puts [list 1 2 3]
07:42:38 <fizzie> 1 2 3
07:42:38 <fizzie> % puts [list "foo" "bar" "baz quux"]
07:42:38 <fizzie> foo bar {baz quux}
07:42:41 <fizzie> That's one silly language.
07:43:23 <zzo38> fizzie: Yes it does seem like silly to me, too.
07:43:24 <fizzie> Every time you use 'lindex' to access one element of a list, it goes and parses that string.
07:45:44 <zzo38> fizzie: And that would make it slow, isn't it?
07:45:56 <fizzie> I think it is pretty slow, yes.
07:48:04 <zzo38> How fast is the strlen command in C anyways? Like, how fast would this be: while(i--) p+=strlen(p)+1;
07:48:55 <pikhq> Depends on your libc, but the worst case is going to be the obvious, naive loop.
07:49:41 <zzo38> Do some things also depend on the CPU?
07:49:43 <oerjan> how could it possibly do anything other than scan all of it?
07:49:51 <oerjan> (up to the nul)
07:50:41 <fizzie> oerjan: You're such a computer scientist!
07:51:11 <fizzie> Anyway, it can be a compiler builtin, in which case it might be able to deduce something, but I wouldn't count on that.
07:51:12 <pikhq> oerjan: Scan up to the right alignment, and then scan in words.
07:51:25 <fizzie> pikhq: That is also "scan all of it" to him, I'd wager.
07:51:30 <zzo38> oerjan: I do suppose it cannot work in any other way, but depending on the machine instructions some might be faster?
07:51:30 <oerjan> heh
07:51:36 <pikhq> That is a fairly common optimisation, though obviously only changed constant factors.
07:51:38 <fizzie> As long as it's O(n) it's all the same.
07:52:17 <zzo38> pikhq: I guess scan in works might be a bit faster, but it has to scan each byte to find where it ends, so the scan words can only be used for reading memory not for calculating the length.
07:52:34 <fizzie> It can be done with REP SCASB or something like that on x86 too, but I think it's faster to do something word-oriented.
07:52:57 <fizzie> I do know glibc's memcpy tries to use the wide SSE registers and loops instead of the naive rep movsb.
07:53:27 <pikhq> zzo38: There's some moderately clever bitwise operations you can do on the words.
07:53:49 <zzo38> You could do it with: while(*string) string++,length++; but that doesn't deal words or optimize to the machine.
07:53:53 <fizzie> I recall one processor (maybe ARM, or SH-3 or something) that had a special opcode for "test if any of the four bytes of a 32-bit word equals 0", specifically for string-scanning.
07:54:03 <zzo38> pikhq: Yes maybe there is like that
07:54:28 <pikhq> zzo38: Even if it is more actual opcodes than the naive loop, it generally comes out on top because fetching from memory is expensive.
07:54:33 <kfr> rep movs* hasn't been efficient in many x86 generations if I'm not mistaken
07:55:16 <pikhq> zzo38: Though at this point for quite a bit of it we're comparing a register to an L1 fetch.
07:55:52 <zzo38> pikhq: It is possible, yes. Including if the processor allows accessing individual bytes of a register that was loaded from words.
07:56:35 <zzo38> But the instructions must also be stored in RAM, unless it is cached, which can make it faster.
07:57:15 <pikhq> Oh, dang. The BSD libc's one is also branchless for the checking-for-any-\0s.
07:57:44 <pikhq> That comes out quite a ways ahead on modern CPUs.
07:57:48 <kfr> I've seen the Dinkumware strlen implementation
07:57:52 <kfr> It used quite a lot of bit hackery
07:58:26 <pikhq> ((x - 0x01....01) & ~x & 0x80....80)
07:58:28 <fizzie> Current glibc strlen is like this: http://sourceware.org/git/?p=glibc.git;a=blob;f=string/strlen.c;h=5f22ce95097d4090c6c32fc7cf6c2ef9cf6e86a8;hb=HEAD
07:58:39 <fizzie> I've seen it be more complicated-looking earlier, though.
07:58:45 <pikhq> That is non-zero if any of the bytes in x are 0.
07:59:26 <kfr> http://siyobik.info/index.php?module=pastebin&id=584
07:59:34 <kfr> That's the Dinkumware one
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:54 <fizzie> glibc has machine-specific variants of some things (like memcpy) somewhere too, I just can't recall the folder and the web-repo isn't very find'able.
08:00:55 <zzo38> But I think that is only for 64-bit computers?
08:01:15 <kfr> No, that's AMD64 code
08:01:15 <pikhq> zzo38: It's for n-bit computers.
08:01:26 <pikhq> zzo38: Well, the algorithm is.
08:01:28 <kfr> Oh you mean the other one
08:02:27 <fizzie> Oh right, it was the sysdeps one.
08:02:34 <fizzie> Here's the x86-64 strlen: http://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/x86_64/strlen.S;h=28f828780e9b6449aa1ac077c53586ab0ec5e50d;hb=HEAD
08:03:08 <fizzie> Curiously on i386 it in fact does do repnz scasb.
08:03:42 <kfr> Haha SSE
08:03:48 <kfr> I once wrote an SSE strlen
08:03:50 <fizzie> glibc's memcpy is the one with all kinds of different-sized loops: http://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/x86_64/memcpy.S;h=b4545ac9f704deb1b11e44be8ffa4bce03c9aab3;hb=HEAD
08:04:05 <pikhq> On an actual i386, I suppose repnz scasb would actually be reasonably efficient.
08:04:06 <fizzie> With prefetchnta's and movntiq's and everything.
08:04:17 <pikhq> What with a complete lack of pipelining.
08:04:30 <zzo38> What is the speed compare and energy compare between arithmetic operation and bitwise operation?
08:04:48 <pikhq> zzo38: Negligible.
08:06:00 <kfr> zzo38 it greatly varies
08:06:21 <kfr> Mind you, "arithmetic" includes multiplication and division :p
08:07:08 <pikhq> Ah, right, multiplication and division are relatively expensive operations.
08:07:25 <pikhq> Addition and subtraction are hardly distinct from bitwise operations.
08:07:27 <kfr> Integer multiplication/division used to be pretty harsh
08:07:34 <kfr> Nowadays they are pretty fast though, sec
08:08:06 <zzo38> x86 does have AAM and AAD commands, does GNU C compiler ever use those in a compiled program?
08:08:55 <pikhq> kfr: Still more expensive than addition, AKA "xor with carry".
08:10:02 <olsner> zzo38: those are removed (cause invalid-opcode exceptions) in 64-bit mode
08:10:17 <kfr> zzo38: Only a small fraction of the instructions are generally generated
08:10:36 <kfr> 32-bit MUL has a latency of 3
08:10:39 <kfr> 64-bit MUL has a latency of 5
08:10:53 <zzo38> olsner: Is AAA also removed, or not?
08:10:54 <kfr> ADD, SUB, AND, OR, etc are all 1
08:10:55 <Lymia> !fyb crash :......;@<++!*
08:10:59 <pikhq> zzo38: x86 is going to be treated by modern compilers a lot like a RISC with a lot of quirks and completely useless instructions...
08:11:10 <EgoBot> Score for Lymia_crash: 3.2
08:11:40 <olsner> zzo38: yep
08:11:57 <fizzie> And DAA, but that's not surprising either.
08:12:04 <pikhq> kfr: That's pretty impressive.
08:12:28 <olsner> pretty sure they removed all the BCD instructions
08:12:44 <fizzie> They also threw away PUSHA/POPA.
08:12:55 <kfr> Ah but DIV is still very expensive
08:12:56 <pikhq> Oh god *right* x86 has BCD instructions.
08:13:11 <kfr> The latency is roughly around 24
08:13:25 <kfr> Can be as great as 72 though
08:13:37 <fizzie> olsner: At least they've kept XLAT, so not all the really quirky single-use instructions have been eliminated.
08:13:52 <zzo38> AAM and AAD are still seems useful for some kinds of multiplication and division (it is not limited to base ten and can be usable for things other than BCD), though.
08:13:54 <pikhq> I do know that compilers are pretty aggressive about optimising DIVs into bitwise operations whenever possible, at least.
08:15:36 <kfr> pikhq: That's just one special case for a constant divisor
08:15:47 <kfr> In general you use multiplication to achieve division by a constant divisor
08:17:04 <pikhq> Ah, right.
08:17:18 <pikhq> Doesn't help at all with variable divisors, of course.
08:22:29 <kfr> Yeah
08:23:41 <zzo38> Sometimes using AAM and AAD and those kind of commands will make the program code smaller, but it will be slower.
08:35:56 -!- pingveno has quit (Ping timeout: 240 seconds).
08:37:59 -!- pingveno has joined.
08:41:22 <kfr> Oh no, I just realised that I might have to optimise for tail recursion if I were to offer no execution flow control other than function calls (i.e. recursion)
08:42:18 <oerjan> to optimize for tail recursion, you have to optimize for tail recursion.
08:42:32 <zzo38> kfr: Yes you do, even TeX is designed optimized for tail recursion for the same purpose. Often at the end of one macro you might have a name of another macro which takes the next parameters from afterward
08:46:03 <kfr> Storing everything in nested arrays of integers must be brutal to do more structured programming though :/
08:46:11 <zzo38> The AAM command is a useful kind of divmod by a constant.
08:46:21 <zzo38> (For 8-bit values)
08:46:37 <kfr> It has a latency of 15 lol
08:47:02 <zzo38> And it sets zero flag according to the remainder.
08:47:28 <kfr> I won't have first class functions or polymorphism or anything like that though :|
08:47:35 <kfr> And strict evaluation, of course!
08:47:44 <zzo38> In places where you want small code, you could save many instructions.
08:47:49 <kfr> Not lazy like Hatkell
08:48:25 <zzo38> In some places in your program you might want fast code, and other places with small code, depending on the purpose of those sections of the code.
08:50:07 <zzo38> XLAT is not useless either.
08:59:09 <kfr> http://en.wikipedia.org/wiki/APL_syntax_and_symbols <3
09:01:08 <zzo38> I have also think, of one esolang idea, that instead of Unicode it uses the Computer Modern mathematics symbols and other symbols, including accents and overstrike.
09:24:34 <kfr> Doesn't ring a bell
09:24:39 <kfr> Googled, got mixed results
09:24:43 <kfr> zzo38 got an example of those?
09:42:06 -!- poiuy_qwert has quit (Ping timeout: 264 seconds).
09:45:02 <zzo38> kfr: The Computer Modern typefaces are the ones used by default in TeX (although you can use your own fonts, too).
10:16:51 -!- asiekierka has quit (Read error: Operation timed out).
10:33:44 <kfr> Wait a second! Strict evaluation in FP makes no sense!
10:42:55 -!- choochter has joined.
10:44:11 <kfr> if blah [print "a"] [print "b"]
10:44:18 <kfr> Would print ab haha
10:44:24 <kfr> Damn side effects!
10:44:58 <zzo38> You can make a functional programming language that doesn't have side effects then
10:45:27 <kfr> Yeah I was just thinking about that
10:45:34 <kfr> It just takes crap from stdin in the beginning
10:45:53 <kfr> But hmm in the end it must print something
10:46:00 -!- ais523 has joined.
10:46:13 <zzo38> kfr: It should print the result of the entire program
10:46:19 <kfr> Yeah
10:46:49 <kfr> I was also thinking about how I can avoid out of range errors on arrays entirely
10:46:57 <kfr> By making it impossible somehow
10:47:19 <kfr> I'm not just talking about range checks
10:47:30 <kfr> I'm talking about preventing it in the semantics of the language somehow
10:47:50 <oerjan> needs dependent types afaiu
10:48:01 <kfr> Oh no, like Agda?
10:48:12 <kfr> That sounds complicated
10:48:15 <oerjan> something like that
10:50:36 <kfr> Or I could just refuse to provide any kind of just being able to access a particular index.
10:51:46 <oerjan> just mapping and for loops? right but that could be inefficient for some things
10:51:46 <kfr> Oh, but even head on an empty list would cause a runtime error
10:51:57 <kfr> Haha efficiency is the least of my concerns
10:52:02 <kfr> This is just nuttery
10:52:15 <ais523> kfr: welcome to #esoteric!
10:52:30 <ais523> dependent types are interesting in that they solve a lot of problems
10:52:35 <ais523> but people consider them too much effort anyway
10:52:39 <zzo38> One way is to not have a array index command
10:52:40 <ais523> perhaps they're even correct
10:52:57 <kfr> zzo38 but you need to have some way to access an element in an array
10:53:34 <zzo38> kfr: You can have maybe some map that passes the index number and value to a function, for each element in the array.
10:53:39 <oerjan> :t Data.Array.Mutable.Array i x -> [(i,x)]
10:53:40 <lambdabot> parse error on input `->'
10:53:46 <zzo38> And also the return value becomes the new value in the array.
10:53:46 <oerjan> erm
10:53:52 <oerjan> @hoogle Data.Array.Mutable.Array i x -> [(i,x)]
10:53:52 <lambdabot> Parse error:
10:53:53 <lambdabot> --count=20 "Data.Array.Mutable.Array i x -> [(i,x)]"
10:53:53 <lambdabot> ^
10:54:07 <ais523> err, what?
10:54:10 <zzo38> This way you can change a value by making a function, that check the index number, if it is the one you want to change, return a new value, otherwise return the old input value.
10:54:14 * oerjan isn't getting this right
10:54:26 <oerjan> @hoogle Array i x -> [(i,x)]
10:54:26 <lambdabot> Data.Array.IArray assocs :: (IArray a e, Ix i) => a i e -> [(i, e)]
10:54:26 <lambdabot> Data.Graph.Inductive.Graph lpre :: Graph gr => gr a b -> Node -> [(Node, b)]
10:54:26 <lambdabot> Data.Graph.Inductive.Graph lsuc :: Graph gr => gr a b -> Node -> [(Node, b)]
10:55:05 <ais523> hmm, apparently the resurfacing of example.com broke darcs
10:55:36 <oerjan> ais523: wat
10:55:49 <kfr> I thought about providing nothing but the following types: Int, [Int], [[Int]], [[[Int]]] etc
10:55:55 <kfr> To make it really simple
10:56:04 <ais523> oerjan: the test suite checked to see whether 404s were handled properly by looking for a nonexistent page there
10:56:23 <ais523> they changed it to http://darcs.net/nonexistent in order to make sure the page was a 404
10:58:53 <ais523> kfr: to make it even simpler, just provide [[[[[[...]]]]]]
10:58:54 <oerjan> zzo38: i think if you use that method there is little reason to use an array rather than a linked list, since you are always updating all of it
10:59:10 <ais523> oerjan: arrays have better cache performance than linked lists
10:59:14 <kfr> ais: Huh? I'm not sure what that is supposed to mean
10:59:24 <oerjan> ok maybe that
10:59:45 * oerjan has been officially declared O(n)-blind
11:00:41 <ais523> kfr: the only type is a list of that type
11:00:50 <kfr> Hm but the easiest way to take care of this index issue is to simply check the size whenever there's an access and when it's out of bounds -> terminate and print an error
11:01:04 <ais523> I think that's enough support for data in the language in order to bootstrap arithmetic
11:01:22 <oerjan> kfr: i thought you said you _didn't_ want to just do range checking
11:01:25 <ais523> (I'm the sort of person who tends not to add arithmetic to a language unless it actually needs it, except maybe in a wimp mode)
11:01:43 <kfr> oerjan: I can't come up with a better way :|
11:02:20 <kfr> ais523 I want to make a self hosting compiler so I'll have a hard time without any arithmetic
11:02:25 <oerjan> ais523: that [[[...]]] seems almost exactly what elliott seemed to be constructing a few hours ago
11:02:54 <ais523> oerjan: I think it's what Ursala does behind the scenes
11:03:10 <ais523> and OK, Ursala's not technically an esolang, but it's still hilarious
11:03:21 <oerjan> mind you he also wanted to use only "natural" list operations
11:03:24 <ais523> (it's in the same sort of category as BancSTAR)
11:03:56 <oerjan> and of course it is also in some sense what ZFC set theory does
11:04:04 <kfr> Have any of you actually written a self hosting compiler for anything?
11:04:28 <kfr> Or even opcode generation from an intermediate form in general?
11:04:40 <oerjan> not me
11:04:47 <kfr> :[
11:05:48 <ais523> hmm, I've written a bunch of compilers, but I'm not sure if any self-host
11:06:11 <kfr> ais523 oh so you have dealt with code generation?
11:06:22 <kfr> IA-32/AMD64?
11:06:23 <kfr> PE/ELF?
11:06:55 <ais523> mostly because I'd hate to, say, have to write an INTERCAL compiler in INTERCAL
11:07:07 <ais523> kfr: I rarely go all the way to asm
11:07:14 <oerjan> self-hosting those circuit compilers ais523 seems to be doing would be something impressive
11:07:15 <fizzie> I've written one Scheme compiler that with the "I'd like to have something self-hosting" thought, but it got sort of abandoned mid-way; the compiler works fine, and does compile a reasonably large set of code, but I don't think it quite does itself yet.
11:07:24 <kfr> I wouldn't even generate assembly
11:07:28 <ais523> with esolangs, translating to C or a similar low-level lang is enough
11:07:36 <kfr> ais523: Weak
11:07:41 <ais523> oerjan: indeed, I'd love to pull that off, but it seems a little implausible
11:08:04 <ais523> the hardware compilers would go to VHDL/Verilog
11:08:10 <ais523> kfr: there's nothing really special about asm, though
11:08:22 <ais523> I've also done some work on gcc-bf, but it's far from finished
11:08:32 <ais523> (a brainfuck-targeting backend to GCC)
11:09:01 <ais523> and that goes via an asm I designed for the purpose of targeting BF
11:09:08 <ais523> really, though, gcc is a mess for that sort of thing
11:09:17 <ais523> perhaps I'll look at modern gcc with its plugin architecture, or llvm
11:09:48 <fizzie> I have that Funge-98 compiler too, but it really isn't self-hosting, and also quite incomplete.
11:10:00 <ais523> oh, funge-98 in funge-98?
11:10:03 <Ilari> Haha... How to fail password security: Give user password they can't change and the password is weak (dictionary word!)...
11:10:10 <ais523> how far does it get in Mycology?
11:10:13 <fizzie> ais523: No; that's why it's not self-hosting. :p
11:10:19 <ais523> ah
11:10:23 <ais523> that could be an interesting project
11:10:37 <fizzie> I guess if you're targeting Funge-98 it's easy. :p
11:10:46 <ais523> although funge is basically impossible to compile no matter what lang you write the compiler in, that's the whole point
11:10:50 <ais523> what about an interp?
11:11:03 <fizzie> There's that 93 self-interp, befbef.bef or whatever.
11:11:11 <fizzie> A bit limited when it comes to code-space.
11:11:21 <ais523> (without just cheating by copying yourself to negative space, copying the input program into positive space, then deleting yourself and running into the start of the input program afterwards)
11:11:34 <fizzie> I'm not sure if anyone's done a proper Funge-98 one. I *think* there was one, but not entirely sure.
11:13:02 <fizzie> http://esolangs.org/wiki/EsoInterpreters does list two self-interpreters for -93, but none for -98.
11:13:53 <fizzie> Anyway, there's also a reasonably large subset of Funge-98 programs that can be compiled completely statically.
11:14:37 <fizzie> (Even without going to absurd lengths.)
11:15:39 -!- oerjan has quit (Quit: Good night).
11:20:28 <Ilari> The ones that don't ever execute potentially modified code?
11:22:29 <fizzie> Well, that's a hard condition to detect. But you can approximate. (And you could handle some programs that do; say a program does '>00p in one place and '<00p at another; that's just flipping a branch at (0,0).)
11:22:53 <fizzie> My static compiler does a very heuristic code-flow analysis when it comes to complicated things like j.
11:23:11 <fizzie> Where "heuristic" is here in the traditional meaning of "half-assed".
11:25:29 -!- maximum_yellow has joined.
11:28:10 <kfr> I'm not sure what UTF-8 symbol I should use for the if statement hmm
11:28:48 <fizzie> Oh no, I feel a nitpick coming onto me.
11:29:09 <maximum_yellow> ¿
11:29:15 <maximum_yellow> kfr: ^
11:29:45 <fizzie> Here it comes: there is no such thing as a "UTF-8 symbol"; it's just an encoding for Unicode. (And the Unicode glossary doesn't define a meaning for "symbol" either, but I'm not *that* nitpicky.)
11:30:12 <zzo38> In Plain Texnicard, what should be the maximum number of set symbols per set, and what should be the maximum number of modes per set symbol? (Their product must not exceed 256.)
11:31:10 <kfr> fizzie is UTF-8 encoded codepoint any better?
11:31:34 <zzo38> (For example, of each symbol comes in two sizes, with one border color (or gradient), and one fill color (or gradient), then you need four modes: border of small symbol, border of large symbol, fill of small symbol, fill of large symbol.)
11:31:47 <fizzie> Well, that's fine, I guess, though I don't quite see why to mention UTF-8 at all, unless you're choosing the code point based on how pretty the encoded bits are.
11:31:53 <fizzie> For some reason I kind-of like the idea of using the "option key" symbol for if -- that is, ⌥ -- but it's really obscure.
11:32:09 <kfr> Well, for the choice it doesn't matter but the compiler will depend on a particular encoding
11:32:10 <ais523> zzo38: make them both 16 as a starting point, if you run out of one but not the other you can shift the requirements
11:32:45 <kfr> fizzie haha I'd like to see the set that one is from
11:33:02 <zzo38> ais523: OK, that should work. It was my first thought, 16 of each.
11:33:07 <fizzie> The block is the "miscellaneous technical" one, the same place that has all the APL symbols.
11:33:12 <zzo38> I do suppose I can change it later.
11:33:24 <kfr> http://en.wikipedia.org/wiki/%E2%8C%A5
11:33:42 <zzo38> fizzie: Is the "option key" symbol the one also called the "place of interest" symbol?
11:33:57 <zzo38> No, never mind. I am wrong
11:33:59 <fizzie> zzo38: No, that's the "command key".
11:34:13 <zzo38> The "command key" symbol is the "place of interest" symbol.
11:34:22 <zzo38> I made a mistake since I never use Apple computers
11:34:47 <zzo38> (I did make the "place of interest" ("command key") symbol in METAFONT, once.)
11:35:00 <zzo38> I think I did the option symbol, too.
11:36:03 <kfr> http://www.fileformat.info/info/unicode/block/miscellaneous_technical/utf8test.htm
11:36:07 <kfr> It's from that set haha
11:36:50 <fizzie> It's got the silly top/bottom halves of integrals and sums and brackets, too.
11:36:53 <zzo38> I think METAFONT is a good program to design fonts.
11:36:56 <fizzie> Like the name says, "miscellaneous".
11:37:32 <fizzie> ⎇ is another alternative for ⌥.
11:43:37 <fizzie> If you want the totally obscure character for "if", use U+1D30E TETRAGRAM FOR BRANCHING OUT: http://www.fileformat.info/info/unicode/char/1d30e/index.htm
11:44:39 <fizzie> There are quite a few other useful programming-related concepts in the block, too, and they all look alike, which will make the language look more harmonious. Not to mention harder to read.
11:53:05 -!- zzo38 has quit (Remote host closed the connection).
12:20:39 <kfr> lol.
12:21:00 <kfr> http://www.fileformat.info/info/unicode/block/tai_xuan_jing_symbols/utf8test.htm
12:21:03 <kfr> Definitely not.
12:32:56 -!- variable has joined.
12:47:29 <Ilari> This IP address counter is going to hit zero today at this rate...
12:47:53 <Ilari> Okay, it shows first of february, but that could be the timezones.
12:47:54 * kfr is on an IPv6 only host
12:48:02 <kfr> Ping my hostname for great justice.
12:49:16 <fizzie> Aw, vanity v6 address assignments like that are so 2000s.
12:49:42 <fizzie> (Or is it "the 00s"?)
12:49:49 <Ilari> rtt min/avg/max/mdev = 122.129/159.620/224.113/41.806 ms
12:49:49 <kfr> It's the AAAA only record :[
12:49:56 <kfr> Many people are irrtated by that
12:50:00 <kfr> irritated*
12:50:12 <fizzie> Sure, but using :fade:fade:fade:fade...
12:50:14 <kfr> They go like "aozomg it says unknown host!"
12:50:46 <kfr> Then again changing DNS records after you're on the server is even funnier
12:50:56 <fizzie> rtt min/avg/max/mdev = 64.248/65.609/74.548/2.580 ms
12:51:01 <kfr> I fooled somebody into thinking I was connecting from microsoft.com once
12:51:14 <kfr> Or just removing the record entirely is hilarious, too
12:51:44 <fizzie> Occasionally I've wondered whether ping's "mdev" is in fact standard deviation or not. I would assume it is, but I'm not sure what the "m" is trying to say.
12:52:20 <fizzie> Oh, it's mean deviation.
12:52:28 <fizzie> Strange statistic to report.
12:52:57 <fizzie> Well, or maybe it's the std dev with a strange name.
12:53:10 <kfr> lol I am so going to use ⨝ for joining arrays.
12:53:30 <kfr> It's great that there are Unicode symbols for database relational algebra stuff
12:53:44 <Ilari> In some cases, it is easiest to just make up host ID. Such as when something blocks off RAs but not connectivity.
12:54:44 <Ilari> Yes, I have heard of cases where one has to manually configure IPv6 addresses and gateways and then it'll work.
12:54:50 <kfr> There's an insertion symbol: ⎀
12:56:05 <ais523> <kfr> I fooled somebody into thinking I was connecting from microsoft.com once <--- didn't they check forwards and reverse and make sure they were equal, like anyone should if they want to make sure that a DNS is authoratitive?
12:56:18 <kfr> Of course not
12:56:25 <kfr> Otherwise it wouldn't have worked, duh!
12:57:47 <fizzie> IRC servers don't tend to check either, and they only report the reverse-name they got (and not the address) in whois and such, so I don't see how a J. Random User could really check.
12:57:53 <Ilari> Weird stuff going on local systems: Two interfaces with the same IP, same IPv6 /64 used for two segments...
12:58:05 -!- asiekierka has joined.
12:58:35 <fizzie> I have a really hacky /64-sharing thing going on at home.
12:59:09 <Ilari> How hacky?
12:59:10 -!- Phantom_Hoover has joined.
12:59:15 <ais523> fizzie: why?
12:59:31 <ais523> as in, why share a /64 when, say, a /60 would be trivially available?
13:00:01 <fizzie> ais523: The ISP only gives out a /64 to random home DSL connections. (Well, by default, anyway. Maybe it could be negotiable. But they could also ask for money there.)
13:00:20 <ais523> fizzie: oh, it's an attempt to persuade you to pay them more
13:00:38 <Phantom_Hoover> Sorry guys, I don't have any whisky.
13:00:40 <ais523> giving people just individual /64s is sort-of as contrary to the spirit of IPv6 as handing out /16s
13:00:59 <fizzie> Giving DSL users individual /64s sounds pretty much like the only sensible thing to do to me.
13:01:12 <Ilari> What hacks does that sharing do?
13:01:17 <fizzie> Otherwise you'd have to agree on one host identifier to use as a gateway and all.
13:01:56 <Phantom_Hoover> :i text
13:02:41 <Ilari> fizzie: As in, what hacks?
13:02:51 <fizzie> Ilari: Well, since they only route the /64 to the link, not to any specific gateway, I have to add proxy-NDP entries for all hosts in the "inner" networks on the gateway (so the ISP's side finds them with ND); so I have a crude kludge that listens for router-solicitations in the inner network, sends faked replies back, then sets up proxy-NDP entries on the outer interface and single-host /128 routes for the inner machines in the inner interface.
13:03:32 <Phantom_Hoover> 03:52:09 <elliott> oerjan: oh my god what sequence is that printing ← how does he not recognise Thue-Morse?
13:03:53 <Ilari> Ah, multiple layer 2 segments...
13:04:30 <ais523> fizzie: oh, I muddled /64 and /128
13:04:35 <ais523> yep, a /64 is entirely sane
13:04:42 <ais523> a single /128 would be ridiculous
13:04:53 <fizzie> Ilari: I used to do it by bridging the two network segments, then ebtables filtering so that only IPv6-protocol Ethernet frames got bridged, but that wasn't any prettier either.
13:05:30 <ais523> 01101001100101101001011001101001
13:05:44 <fizzie> ais523: From what I hear from a friend whose workplace has interwebs from the same ISP, getting a /56 was just a matter of sending an email to the service desk. It is possible it'd work for a home user too.
13:06:03 <kfr> Maybe ∑ is funnier for concatenating lists hmm
13:06:09 <kfr> Or arrays rather*
13:06:15 <ais523> hmm, what's to stop you just putting two different machines at different /128s in the same /64? anything?
13:06:46 -!- cheater00 has quit (Read error: Connection reset by peer).
13:07:22 <Ilari> The problem is that ISP gateway has to be able to ND all the hosts in the network (if they are to be reachable).
13:07:31 <fizzie> ais523: You can't really split a /64, the stateless address autoconfiguration won't work. And also they just route the /64 into the link, not a particular gateway address, so you have to have the gateway reply to ND messages (like IPv4 ARP queries) that "hey, send packets for this IPv6 host into this Ethernet address".
13:08:57 <fizzie> (Also I've poked the RIPE registry with their prefix as a search query, and some dude who's listed in linkedin as "Systems Engineer" working at the ISP has a /48 assigned with a descr: field of "[person's name] DSL", so obviously with the right kind of connetions you'll get more addresses at home...)
13:09:19 -!- cheater00 has joined.
13:09:54 <ais523> OK, so why is Kraftfeld uploading esoprograms in JPEG format?
13:10:48 <Ilari> Wonder what's in that network if even /56 isn't enough? Just for bragging? PI space?
13:13:02 <fizzie> Well, "/48 to end-sites" isn't an unheard-of policy. I don't know how RIPE instructs people nowadays; their instructions list both /48s and /56s as popular end-site network sizes, and then there were some guidelines about how those are aggregated in the whois so that RIPE's WHOIS db doesn't fill up with many small networks.
13:13:15 <fizzie> The assignment was pretty old, I think.
13:14:34 <fizzie> Hm, isn't there a timestamp in inet6num whois entries, or is the client just not reporting that?
13:15:49 <fizzie> It might even have been that they were testing things out there.
13:21:02 <Ilari> The rate this IPv4 counter counts down addresses seems to be about 1300 addresses per minute.
13:21:18 <fizzie> Uh: http://www.db.ripe.net/whois?form_type=advanced&full_query_string=&searchtext=AMRM1-RIPE&do_search=Search&inverse_attributes=author&ip_search_lvl=&alt_database=RIPE&object_type=limerick&object_template=none
13:21:33 <fizzie> Why is the database full of poetry?
13:21:42 <fizzie> (Maybe "full of" is an exaggeration.)
13:22:05 <fizzie> remarks: Role object for limerick working group administrator(s)
13:22:05 <fizzie> remarks: This is the most secret object in the whole database
13:22:05 <fizzie> remarks: Don't ask who's behind this, nobody knows
13:22:05 <fizzie> remarks: Feel free to send in new limericks!
13:24:54 <Ilari> This counter is going to hit zero (at this rate) in about 8 hours 20 minutes...
13:27:30 <ais523> Ilari: until exhaustion of what? IPv4 addresses allocated to end-users? or just to the RIRs?
13:28:02 <Ilari> I don't know exactly what it counts: http://inetcore.com/project/ipv4ec/en-us/index.html
13:31:17 <fizzie> I think their "X-Day" is IANA depletion.
13:31:25 <Ilari> Yup.
13:31:55 <Ilari> Note timezones... In UTC+2h and earlier timezones, the bottom number should hit 0 today.
13:32:23 <fizzie> The counter doesn't exactly look too scientific.
13:32:29 <Ilari> Yeah, it doesn't.
13:32:47 <fizzie> Given in how discrete blocks IANA gives those things out, counting down with a silly number like that is a bit movie-ish.
13:33:38 <Ilari> Yeah.
13:35:40 <Ilari> And of course, there are various uncertainities in IANA allocations. Remeber the 5 blocks being surprise-allocated last fall?
13:36:54 <fizzie> I remember it... like it was yesterday. [Cue dreamy background music and a fade to a flashback sequence.]
13:46:29 -!- FireFly has joined.
13:46:57 -!- cheater00 has quit (Ping timeout: 240 seconds).
13:47:51 -!- cheater00 has joined.
13:49:24 <Ilari> 1300 addresses per minute... That's about a /24 every 12 seconds... /16 every 50 minutes...
13:50:12 <Phantom_Hoover> Is that IPv4 or 6?
13:50:23 <Ilari> v4 of course...
13:50:43 <Ilari> v6 allocation rate is a good bit higher than 1300 addresses per minute...
13:51:15 <fizzie> A /24 of IPv6 every 12 seconds would be 101412048018258352119736256430080 addresses per minute.
13:51:22 <fizzie> I doubt it's quite that high.
13:54:34 <fizzie> Maybe they should've started to number those things from the other end when the /N notation started.
13:55:32 <Ilari> APNIC's been allocating about 1 /48... Per second.
13:56:16 <fizzie> Pshaw, that's just 72535549176877750482370560 addresses.
13:56:20 <fizzie> Per minute, I mean.
13:58:25 <Ilari> Worldwide, that rate is probably double that... So about 140 septillion addresses per minute...
14:00:34 <fizzie> Allocating one /47 per second would mean a total exhaustion in just 4.5 million years. Worrisome.
14:02:04 <Ilari> 600k...
14:06:05 <fizzie> Given that Egypt no longer seems to care about being part of the internet, maybe we could just reclaim all their v4 space? (Though according to one page that's just 0.17x/8.)
14:07:20 <Ilari> Heh... One of the NANOG51 schedule events (for tomorrow) is titled: "Panel: IPv4 Exhaustion What Now?"
14:09:15 <fizzie> "This is a track to expand on the panel I did at NANOG 50" -- called "IPv4 to IPv6 Transition and Co-Existence Experiences". Maybe the panel-moderator thought a more catchy name would help.
14:20:01 -!- asiekierka has quit (Read error: Operation timed out).
14:28:43 -!- augur has quit (Remote host closed the connection).
14:29:37 -!- ais523_ has joined.
14:29:56 <kfr> This is a hello world in a primitive esoteric semi-functional language (i.e. no state/side effects except for writing the return value of the program function to stdout when it terminates) which is statically typed (everything is an unsigned integer, or an array of unsigned integers, or an array of an array of ..., functions aren't first class objects, though) and uses prefix notation with lots of Unicode stuff: http://siyobik.info/misc/esolang/prime.html
14:29:58 <kfr> Thoughts?
14:30:18 <kfr> I took some of the symbols from APL
14:30:46 * Phantom_Hoover has a nervous breakdown.
14:30:52 <Phantom_Hoover> AAAAAAAAAAAAAAAAAAAAAaaa
14:30:56 <kfr> Phantom_Hoover: What
14:31:04 <kfr> You don't like it? :[
14:31:21 <Phantom_Hoover> kfr, no, it's just that Agda has completely spoilt gratuitous Unicode for me.
14:31:28 <kfr> Haha
14:31:40 <kfr> Doesn't Agda actually use ⇾
14:31:42 <kfr> ?
14:31:43 <kfr> Or something like that?
14:31:47 <kfr> Failpaste
14:32:39 <kfr> The first one to figure out the meaning of all the symbols used gets a cookie
14:32:40 <ais523_> kfr: I like the look of it, at least
14:32:45 <kfr> Haha
14:32:57 <kfr> I can't even imagine how complicated it would be to write a self hosting compiler in this...
14:33:38 <Phantom_Hoover> ◼ is clearly "end of {block,definition,whatever}".
14:34:04 <kfr> Yeah, just the end of the function definition
14:34:09 <kfr> (nested functions are not supported)
14:34:09 <Phantom_Hoover> iterator, I assume, does some sort of recursion.
14:34:20 <kfr> :O it's just a name
14:34:21 <Phantom_Hoover> Also, why the hell are you using lambda for named functions?
14:34:46 <kfr> I couldn't come up with a more suited Unicode symbol
14:34:58 <kfr> And I wanted to have a prefix symbol for functions
14:34:58 <Phantom_Hoover> How about just leaving it out?
14:35:14 <kfr> Then it would be more difficult to parse!
14:35:21 <kfr> It would require like... lookahead!
14:35:25 <ais523_> hmm, this computer lab's just gone crazy
14:35:32 <ais523_> nobody has any permission to access anything
14:36:00 <ais523_> it's as if someone ran chmod -R 000 / on the entire network
14:36:00 <kfr> Although with the ◼
14:36:00 <kfr> it's superfluous for sure hm
14:36:15 <kfr> Urgh fail paste again, hatred against the hidden newlines from Firefox
14:36:20 <ais523_> I'm in the middle of a marking session atm, but it's kind-of hard to mark when I can't even open a terminal
14:36:36 <Phantom_Hoover> Is the ⌥ a pattern matching thing?
14:36:52 <kfr> Haha no
14:36:55 <kfr> There is no pattern matching :|
14:37:01 <ais523_> luckily Firefox happened to be open at the time, and is still working
14:37:08 <kfr> Phantom_Hoover: It's the if operator
14:37:24 <Phantom_Hoover> So is = prefix?
14:37:28 <ais523_> also, the entire system's gone really unresponsive
14:37:29 <kfr> Syntax: ⌥ predicate thenValue elseValue
14:37:55 <kfr> = # primes 0
14:37:55 <kfr> means length primes == 0
14:38:17 <Phantom_Hoover> And = 0 | number iterator?
14:38:37 <kfr> | is the APL modulo thing
14:38:57 <Phantom_Hoover> The ↺?
14:38:58 <kfr> So err 0 == number `mod` iterator
14:39:12 <kfr> Hah, that's the recursion operator
14:39:30 <kfr> It just calls the current function it's used in again
14:40:11 <kfr> The ≡ stuff is just supposed to be some let stuff, but it doesn't have a value in this notation hmmm
14:40:16 <Phantom_Hoover> So if you want to do two mutually recursive functions?
14:40:20 <kfr> Whereas it should really
14:40:53 <kfr> Well you can explicitly call other functions, the recursion operator was just a joke abbreviation
14:42:14 <kfr> Ah wait, actually you can basically interpret the ≡ stuff as let ... in constructs right now
14:42:16 <Phantom_Hoover> The empty set sign?
14:42:21 <kfr> That's just []
14:42:30 <kfr> [] :: [Int] if you so wish
14:42:32 <Phantom_Hoover> The sigma?
14:42:42 <kfr> Concatenation of arrays
14:42:59 <Phantom_Hoover> The triangle?
14:43:17 <kfr> △ x is [x]
14:43:47 <kfr> ○ is just head
14:43:59 <kfr> ↓ is the APL drop operator
14:44:15 <Phantom_Hoover> The right-wedge?
14:44:24 <kfr> The ▷ in the signature contains types
14:44:32 <kfr> x means integer
14:44:37 <kfr> ▷x means an array of integers
14:44:44 <kfr> ▷▷x means an array of array of integers
14:44:45 -!- ais523_ has quit (Ping timeout: 265 seconds).
14:44:47 <kfr> And so on
14:44:57 <Phantom_Hoover> How is IO done?
14:45:28 <kfr> The program writes its main return value to stdout in the end, you can't explicitly do any IO in the language itself
14:46:23 <kfr> △ 256 has a codepoint which is too large for that, for example
14:46:28 <kfr> Since that would be more than 0xff
14:46:28 <Phantom_Hoover> Well, with that, input passed as an argument and lazy semantics you can do full-featured IO.
14:46:45 <kfr> Not sure how to handle those cases
14:46:57 <kfr> Just skip it perhaps
14:47:06 <kfr> Or split it up into multiple Char8
14:47:21 <kfr> Anyways yeah this is really terrible
14:47:35 <kfr> Doing structured programming wich such a primitive set of operations must be a huge pain
14:48:00 <Phantom_Hoover> No, not really.
14:48:13 <Phantom_Hoover> Structured programming is an imperative thing, for a start.
14:48:52 <kfr> I mean, I wanted to come up with a simple esolang I can write a self hosting compiler for
14:49:13 <Phantom_Hoover> Compiler into what?
14:49:32 <kfr> Huh? It compiles to IA-32/AMD64 PE/ELF
14:49:59 <Phantom_Hoover> Don't do a functional language, then.
14:50:23 <Phantom_Hoover> High-level abstractions and easy self-hosting do not go particularly well together.
14:50:23 <kfr> Why not? :D
14:50:34 <kfr> True that
14:50:43 <kfr> But this one is actually easy to generate code for, I think
14:51:01 <Phantom_Hoover> Wait, does it have first-class functions?
14:51:04 <kfr> No.
14:51:10 <kfr> It's very primitive.
14:51:19 <Phantom_Hoover> Oh. I suppose that makes compilation much easier.
14:51:22 <kfr> Yeah
14:51:32 <kfr> But imagine representing uhmm some intermediate form in this thing
14:51:49 <Phantom_Hoover> Do you require that ints be unbounded?
14:51:53 <kfr> No
14:52:04 <kfr> I will map them to the native word size
14:52:05 <kfr> :P
14:52:09 <kfr> So 32-bit or 64-bit
14:52:32 <kfr> But imagine storing everything in a [[[[Int]]]] or something like that
14:52:33 <Phantom_Hoover> I think you could compile this into C easily, then.
14:52:35 <kfr> It must be terrible
14:52:39 <kfr> C... pff.
14:52:46 <kfr> That would be weak.
14:53:03 <Phantom_Hoover> Not even particularly sophisticated C.
14:53:15 <kfr> It needs to generate everything itself
14:53:25 <kfr> It would be a self hosting cross platform compiler
14:53:30 <kfr> Otherwise it isn't impressive really
14:53:40 <Phantom_Hoover> Do you need to specify the argument types?
14:53:59 <kfr> Yes, it has no inference at the function level
14:54:17 <kfr> There is just Int, [Int], [[Int]], etc
14:54:28 <kfr> All based on the number of the triangles in front of the name
14:54:33 <kfr> In the signature
14:54:42 <Phantom_Hoover> Do you guarantee that tail call elimination will be performed?
14:55:00 <kfr> I have no idea how to go about that really
14:55:12 <Phantom_Hoover> Tail-call elimination?
14:55:26 <kfr> Yeah
14:55:43 <Phantom_Hoover> It's relatively simple.
14:56:42 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
14:57:51 -!- joaopizani has joined.
14:57:59 <Phantom_Hoover> Basically, if you have a function f x = g <some expression>, when you compile it into assembly, there will be an instruction to call g.
14:58:55 <Phantom_Hoover> So f will work out <some expression>, push it onto the stack (or whatever, I'm doing this based on the x86 C calling convention), then push its current point of execution, then jump to g.
14:59:09 -!- SgeoN1 has joined.
14:59:25 <kfr> I was mostly worried about using up too much memory with the recursion
14:59:39 <Phantom_Hoover> Yeah, that's why you do tail-call elimination.
15:00:24 <Phantom_Hoover> If g = f in that example (and there's a condition so it stops somewhere) the stored points of execution can overflow the stack, which is why you eliminate it.
15:01:26 -!- BeholdMyGlory has joined.
15:01:39 -!- asiekierka has joined.
15:02:01 -!- augur has joined.
15:03:32 -!- ais523_ has joined.
15:03:49 <ais523_> hmm, it's been ages since I've been in /this/ lab
15:04:02 <ais523_> (strangely, this is unrelated to the earlier issue, which somehow fixed itself after a while)
15:04:44 -!- SgeoN2 has joined.
15:04:44 -!- SgeoN1 has quit (Read error: Connection reset by peer).
15:06:52 -!- SgeoN2 has quit (Read error: Connection reset by peer).
15:22:39 -!- copumpkin has joined.
15:28:05 -!- MigoMipo has joined.
15:31:35 <kfr> There, wrote a small introduction: http://siyobik.info/misc/esolang/prime.html haha
15:32:28 <kfr> I guess you would have to write tons of helper functions to retrieve properties from implicit structures stored in massively nested arrays
15:32:35 <kfr> In more sophisticated programs
15:34:23 <Phantom_Hoover> How does division work?
15:35:06 <kfr> Phantom_Hoover: 3 / 2 == 1 :p
15:35:16 <Phantom_Hoover> So it floors?
15:35:22 <kfr> Yeah
15:36:17 <kfr> Forgot to mention the unsignedness, right
15:43:33 <ais523_> also, wtf: SourceForge hacked (not wtf), they make a full disclosure post talking about what happened (not wtf), many comments complain about the loss of CVS and talking about how much better it is than SVN (wtf)
15:44:39 <kfr> lol
15:44:41 * kfr uses git
15:45:35 <Phantom_Hoover> kfr, well, there's one small way you can delay your firey death at elliott's hands.
15:45:48 <kfr> Phantom_Hoover why would they want to slay me?
15:45:59 <kfr> Because of my esolang example?
15:48:04 <Phantom_Hoover> Wait, what? What have you got against IRC logs?
15:48:58 <Phantom_Hoover> http://en.wikipedia.org/wiki/Toilet_paper_orientation
15:49:01 <Phantom_Hoover> Oh god.
15:49:21 <Phantom_Hoover> It... look at all the references
15:49:53 -!- asiekierka has quit (Remote host closed the connection).
15:53:11 <ais523_> Phantom_Hoover: I doubt elliott will slay anyone for VCS choice until scapegoat is finished
15:53:18 <ais523_> and then demand everyone switches to it at once
15:53:35 <Phantom_Hoover> ais523_, but he ALREADY hates people who are pro-SVN!
15:53:47 -!- acroyear2 has joined.
15:54:01 <ais523_> Phantom_Hoover: I'm surprised that there are people who think CVS > SVN, though
15:54:07 <ais523_> even people who hate SVN generally hate CVS more
16:01:01 -!- pikhq has quit (Ping timeout: 246 seconds).
16:01:14 -!- pikhq has joined.
16:02:29 -!- Zuu_ has changed nick to Zuu.
16:06:07 <fizzie> ais523: Yeah, the main complaint about SVN I've heard from elliott is "it's supposed to be 'CVS done right', which is impossible".
16:10:34 <ais523_> I thought that was a Linus Torvalds quote/misquote?
16:15:27 <fizzie> The impossibility, or the first part? I don't know where it's from, but I do think SVN people characterize themselves that way.
16:16:46 <ais523_> the impossibility part
16:18:15 <ais523_> hmm, perhaps it wasn't Torvalds, I can't find anything relevant on wikiquote
16:19:35 -!- fizzie has quit (Read error: Operation timed out).
16:26:47 <kfr> <ais523_> I thought that was a Linus Torvalds quote/misquote?
16:26:52 <kfr> That's a correct Torvalds quote
16:26:56 <kfr> I watched that presentation
16:43:43 <quintopia> has the toilet paper orientation wp page gone viral?
16:46:59 -!- ais523_ has quit (Quit: Page closed).
16:53:40 -!- acroyear2 has quit.
16:54:15 -!- asiekierka has joined.
16:59:02 -!- impomatic has joined.
17:07:37 <ais523> <Wikipedia> Sometimes toilet paper is simply entertaining.
17:07:51 -!- Wamanuz has quit (Remote host closed the connection).
17:09:01 <ais523> hmm, theory: there's a serious attempt to get that article featured in time for it to be put on the Main Page on April 1
17:09:42 -!- Wamanuz has joined.
17:12:14 -!- sftp_ has joined.
17:12:23 <quintopia> that's probably it
17:12:39 <quintopia> i had another theory earlier
17:12:48 <quintopia> i forgot it
17:12:56 -!- sftp has quit (Ping timeout: 276 seconds).
17:14:08 <ais523> hmm, apparently that theory is incorrect, I know where the discussions for such things take place and that article hasn't been suggested
17:14:28 <quintopia> suggest it!
17:16:52 <ais523> I was thinking about it, but I don't have the time to carry such a nomination through
17:17:58 <quintopia> mm
17:19:28 <ais523> btw, in our house, the toilet paper isn't placed in a dispenser at all
17:19:34 <ais523> but just left to stand on end
17:23:32 <Phantom_Hoover> ais523, what's your attitude towards LiquidThreads?
17:24:10 <ais523> Phantom_Hoover: I think it's mostly unnecessary, in that the :::-style version of wiki communication is both simpler and more flexible
17:24:20 <Phantom_Hoover> I agree!
17:24:44 <Phantom_Hoover> Well, there are a couple of points in its favour, like less strain on the database.
17:34:49 <quintopia> anyone know where zzo38 is from?
17:34:55 <Phantom_Hoover> Canada.
17:35:12 <ais523> zzo38 parallel Canada
17:35:18 <ais523> it's like Canada, except zzo38
17:35:47 <Phantom_Hoover> Hence it is ten orders of magnitude more crazy than normal Canada.
17:39:51 -!- asiekierka has quit (Remote host closed the connection).
17:40:35 <quintopia> french canadia i bet
17:43:24 <Phantom_Hoover> quintopia, he transcends nationality and ethnicity.
17:43:28 <Phantom_Hoover> He is simply Crazy.
17:45:04 -!- choochter has quit (Quit: lang may yer lum reek..).
17:45:52 <quintopia> Someone come up with a language that is deserving of the name Bugger Overflow please.
17:49:00 <Phantom_Hoover> Hmm.
17:49:29 <Phantom_Hoover> Perhaps it is named that way because whenever you write programs in it you end up saying "bugger, overflow!"
17:50:35 <ais523> happy australian mailman mailing list reminders day!
18:02:14 -!- elliott has joined.
18:17:55 <elliott> 06:36:06 <Lymia> I assume a normal language with convoluted enoguh syntax will do.
18:17:56 <elliott> no, we hate those. generally
18:18:00 <elliott> 06:36:21 <kfr> Supporting both Windows PE and Linux ELF
18:18:00 <elliott> but why
18:18:10 <elliott> (logreading in action!)
18:18:56 <Phantom_Hoover> elliott, wait 'till you see kfr's esolang.
18:19:14 <elliott> It looks like he's fallen into the old trap of "weird syntax = interesting esolang".
18:19:52 <elliott> Phantom_Hoover: Works for me. Download the binary, perhaps it was updated.
18:20:15 <Phantom_Hoover> elliott, where'd you get it from?
18:20:25 <elliott> Phantom_Hoover: The...site?
18:20:27 -!- fizzie has joined.
18:20:30 <elliott> http://www.bay12games.com/dwarves/
18:20:38 <Phantom_Hoover> Yeah, that's where I got it.
18:20:38 <elliott> Did you think it was pay-for or something?
18:20:44 <elliott> Phantom_Hoover: You realise that programs get updated.
18:20:59 <Phantom_Hoover> elliott, I got it literally 5 minutes ago.
18:21:12 <Phantom_Hoover> I doubt somehow that it has broken in the interval between us getting it.
18:21:14 <elliott> Phantom_Hoover: Sigh. What error.
18:21:33 <cheater00> is there a language in which the concept of sequence convergence is the basic concept you work with?
18:22:11 <elliott> 07:02:48 <oerjan> i think it was encoding brainfuck
18:22:14 <elliott> indeed, bifro
18:22:15 <Phantom_Hoover> ./libs/Dwarf_Fortress: error while loading shared libraries: libSDL_image-1.2.so.0: wrong ELF class: ELFCLASS64
18:22:22 <Phantom_Hoover> Bifro!
18:23:14 <elliott> Phantom_Hoover: you need 32-bit sdl.
18:23:20 <Phantom_Hoover> elliott, *sigh*...
18:23:49 <elliott> Phantom_Hoover: you are starting it with ./df right?
18:23:52 <Phantom_Hoover> Yes.
18:24:21 <elliott> well, i don't have 32-bit sdl here and it works
18:24:59 <Phantom_Hoover> You're on Ubuntu, right?
18:25:52 <elliott> yes
18:26:09 <elliott> In addition to the hardware requirements (which will be the same as the other
18:26:09 <elliott> platforms) your system will need these libraries installed:
18:26:09 <elliott> * GTK+ 2+
18:26:09 <elliott> * SDL 1.2+
18:26:09 <elliott> * SDL_image
18:26:10 <elliott> And some kind of OpenGL implementation, so:
18:26:12 <elliott> * libgl
18:26:16 <elliott> * libglu
18:32:11 <Phantom_Hoover> elliott, so I'm screwed?
18:32:23 <elliott> Phantom_Hoover: No, you just have to figure out the solution yourself because I don't know.
18:46:20 <cheater00> o shit, eye of sauron! http://en.wikipedia.org/wiki/Fomalhaut
18:49:09 -!- Behold has joined.
18:50:10 <quintopia> what qualifies a language as being "Low-level"...is it anything remotely tarpit-like?
18:50:57 <Phantom_Hoover> quintopia, ...no?
18:50:57 <ais523> quintopia: basically, it's tarpits, to some extent or another
18:51:05 <ais523> including ones which aren't really minimized
18:51:08 <Phantom_Hoover> Oh, by the esolang definition.
18:51:13 <Phantom_Hoover> I have no idea, then.
18:51:22 <ais523> basically, if you need to go through stupid hoops to even do simple arithmetic, it's probably low-level
18:51:27 <quintopia> oh okay
18:51:59 <Phantom_Hoover> ais523, isn't that more or less all esolangs?
18:52:06 <ais523> Phantom_Hoover: indeed
18:52:21 <ais523> but, say, befunge-98 is what I'd consider "high level" in esolang terms
18:52:23 <ais523> (-93 isn't)
18:52:31 -!- BeholdMyGlory has quit (Ping timeout: 260 seconds).
18:52:35 <ais523> good library support, no real hoops other than those inherent in the structure
18:53:10 <quintopia> http://esoteric.voxelperfect.net/wiki/ETAS
18:53:16 <elliott> ais523: underload isn't low-level
18:53:19 <elliott> nor is Pixley
18:53:27 <elliott> but both have non-trivial arithmetic
18:53:30 <ais523> elliott: I consider underload low-level
18:53:31 <elliott> (OK, underload not so much)
18:53:42 <ais523> precisely because you have to build everything from the ground up
18:53:46 <ais523> even arithmetic and flow control
18:53:52 <ais523> you can't get much lower than that, in an abstract sense
18:54:04 <ais523> it isn't low-level in the sense that it strongly resembles machine code for an actual machine
18:54:13 <ais523> but then, what esolang does, apart from some of the asms that aim at BF?
18:55:54 <Phantom_Hoover> elliott, incidentally, the best advice from #debian wrt DF was "use a chroot".
18:56:03 <Phantom_Hoover> I am going to murder both of the devs.
19:10:15 <elliott> 10:48:08 <kfr> Wait a second! Strict evaluation in FP makes no sense!
19:10:15 <elliott> 10:58:36 <kfr> if blah [print "a"] [print "b"]
19:10:15 <elliott> 10:58:43 <kfr> Would print ab haha
19:10:15 <elliott> 10:58:48 <kfr> Damn side effects!
19:10:18 <elliott> PURITY FAIL
19:10:32 <elliott> non-strict evaluation doesn't help you there either, unless you specify a guaranteed evaluation order
19:10:33 <elliott> which is stupid
19:16:25 <elliott> 11:13:18 <ais523> kfr: to make it even simpler, just provide [[[[[[...]]]]]]
19:16:26 -!- calamari has joined.
19:16:26 <elliott> ais523: hey!
19:16:30 <elliott> ais523: you stole my language!
19:16:36 <elliott> ais523: i was INSPIRED by ursala
19:16:41 <olsner> what's [...]? quoting?
19:16:45 <ais523> olsner: itself
19:16:47 <elliott> olsner: list
19:16:47 -!- calamari has left (?).
19:17:01 <elliott> ais523: he means "is it quoting?"
19:17:03 <elliott> ais523: OK, so,
19:17:13 <elliott> ais523: MY LANGUAGE which I was going to tell you about anyway
19:17:21 <elliott> you know how at the base of ursala, every object is
19:17:24 <elliott> obj := nil | list [obj]
19:17:24 <elliott> ?
19:17:43 <ais523> elliott: yep
19:17:53 <elliott> ais523: I took it ONE FURTHER.
19:17:57 <elliott> obj := nil | cons obj obj
19:18:03 <elliott> ais523: Everything in my language is one of those.
19:18:08 <olsner> I don't get how a deeply nested list is meaningful in the context of kfr's example, so I don't think ais523 meant that?
19:18:14 <elliott> (Accordingly, you can describe it as a tree without even using anything other than lines.)
19:18:20 <elliott> olsner: yes, he did
19:18:28 <olsner> okay
19:18:30 <elliott> olsner: kfr said he'll just have Int, [Int], [[Int]]
19:18:31 <elliott> , ...
19:18:37 <elliott> and ais523 proposed [[[[[[[[[[...]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
19:19:30 <elliott> 11:16:50 <oerjan> ais523: that [[[...]]] seems almost exactly what elliott seemed to be constructing a few hours ago
19:19:30 <elliott> 11:17:19 <ais523> oerjan: I think it's what Ursala does behind the scenes
19:19:35 <elliott> ais523: omg, you're skipping ahead of me
19:20:28 <olsner> elliott: hmm, as in the language would only support list-of-list but not anything deeper?
19:21:21 * olsner still doesn't know what anyone is talking about
19:21:25 <Phantom_Hoover> What's that command that lists the currently-mounted filesystems?
19:21:27 <elliott> olsner: obj := nil | cons obj obj
19:21:29 <elliott> is T= [T]
19:21:36 <elliott> Phantom_Hoover: mount
19:21:40 <elliott> Phantom_Hoover: you may also find df useful
19:22:17 <elliott> ais523: how does ursala do naturals? in mine, a list of N []s is N
19:22:27 <elliott> i.e. 0 = [], 1 = [[]], 2 = [[],[]], 3 = [[],[],[]]
19:22:47 <ais523> elliott: you think I know that sort of thing offhand?
19:22:51 <ais523> it's almost certainly insane, though
19:22:56 <elliott> ais523: absolutely!
19:23:23 <elliott> ais523: I already have operations on (T = [T]) for +, *, and ^ though, that work correctly when using naturals of that form
19:23:28 <elliott> and do something to other lists that may or may not be useful
19:23:35 <elliott> well, + is just append
19:23:43 <elliott> * is cartesian product, except instead of (x,y), it returns (x++y)
19:23:46 <elliott> ^ is just crazy
19:23:51 <elliott> (oerjan thought up ^)
19:40:50 <elliott> ais523: anyway, I finally understand why ursala requires those explicit casts
19:41:17 <ais523> elliott: because it doesn't know the type the rest of the time
19:41:23 <ais523> type info isn't tracked at all
19:41:24 <elliott> ais523: pretty much, yup
19:41:44 <elliott> ais523: in my language, 3 = [0,0,0] = [[],[],[]] = [nil,nil,nil] = [0,nil,[]] = ...
19:41:49 <elliott> (OK, nil is just a name for [], but still.)
19:41:55 <elliott> ais523: oh, = [0,false,[]] too
19:41:57 <elliott> etc.
19:42:08 <ais523> indeed
19:42:21 <elliott> I *think* types are created by writing a clause for is_valid
19:42:21 <ais523> overload was based on that principle, but even simple data structures were infinitely recursive
19:42:28 <elliott> for instance (in a Haskell-style language):
19:42:52 <elliott> is_valid int x := x == [] || (car x == [] && is_valid int (cdr x))
19:43:09 <elliott> and then if you cast e.g. [[[]],[]] to int, it'll fail
19:43:46 <elliott> ais523: and I think "object files" (a huge list of 0s and 1s, where 1 is cons and 0 is nil) will have a first line consisting of an expression representing the type
19:43:47 <elliott> e.g.
19:43:51 <elliott> list_of int\n111101010101011...
19:44:09 <elliott> most commonly "module", I guess
19:47:02 <elliott> ais523: "There is no reason for function application to be left associative in a language without automatic currying, and no reason for automatic currying in a language that distinguishes notationally between product spaces and function spaces (unlike lambda calculi)."
19:47:10 <elliott> ais523: I don't understand this, do Ursala functions not compile to the basic object type?
19:48:18 <ais523> hey, SCI distinguishes between product and function spaces; and it does currying /and/ pairing in order to write functions that take multiple args!
19:48:28 <ais523> that Ursala quote has offended me slightly
19:48:36 <elliott> <elliott> ais523: I don't understand this, do Ursala functions not compile to the basic object type?
19:48:37 <ais523> as finding a reason to make the distinction is the whole point of much of my research
19:48:40 <ais523> elliott: I don't know
19:48:44 <elliott> :(
19:48:46 <elliott> YOU MUST KNOW
19:51:04 <Ilari> The counter is under 148k now... No allocation yet as far as address space registry is concerned.
19:54:47 -!- ais523 has quit (Remote host closed the connection).
20:17:01 -!- copumpkin has changed nick to grue.
20:17:10 -!- joaopizani has left (?).
20:26:03 <elliott> grue: eep
20:26:57 * grue eats elliott
20:27:08 <elliott> it's not dark
20:27:17 <grue> I'm wearing sunglasses
20:27:23 <grue> I got with the times
20:27:40 * grue picks at his teeth to remove bits of elliott
20:29:04 * impomatic activates his Frobozz Magic anti-grue kit
20:29:46 <grue> nah, got the vaccine against that
20:29:53 * grue eats impomatic
20:30:04 <grue> *burp*
20:30:29 * impomatic grumbles about the rules governing grues as he perishes :-(
20:31:23 <quintopia> merp?
20:31:45 -!- adventurer has joined.
20:31:50 <adventurer> GO WEST
20:31:58 <adventurer> KILL GRUE WITH IRON SWORD
20:32:01 <quintopia> i assert that they do not exist
20:32:09 <adventurer> TAKE GRUE'S HEAD
20:32:09 <quintopia> that should be sufficient
20:32:11 <adventurer> GO WEST
20:32:13 <elliott> PUNCH TREE
20:32:14 -!- adventurer has left (?).
20:32:16 <elliott> CRAFT LOGS INTO WOOD
20:32:16 <grue> no
20:32:20 <elliott> CRAFT WOOD INTO STICKS
20:32:25 <grue> I am a constructive proof of the existence of grues
20:32:27 * grue eats quintopia
20:32:30 -!- oerjan has joined.
20:32:32 <elliott> KILL GRUE WITH WOODEN SWORD
20:32:49 <grue> elliott: you're in my stomach and don't have a wooden sword
20:33:06 <quintopia> grue: stop talking. you don't exist.
20:39:28 -!- grue has changed nick to copumpkin.
20:44:25 <cheater00> You are in open forest, with a deep valley to one side.
20:44:26 <cheater00> kill tree
20:44:26 <cheater00> The trees of the forest are large hardwood oak and maple, with an
20:44:26 <cheater00> occasional grove of pine or spruce. There is quite a bit of under-
20:44:26 <cheater00> growth, largely birch and ash saplings plus nondescript bushes of
20:44:26 <cheater00> various sorts. This time of year visibility is quite restricted by
20:44:28 <cheater00> all the leaves, but travel is quite easy if you detour around the
20:44:32 <cheater00> spruce and berry bushes.
20:45:53 <Ilari> Hmm... This depletion counter probably just uses 0000J on the calculated depletion day as the time...
20:49:03 <Ilari> (If the timezone is different than UTC+2, see if you get a different number than about 73k on http://inetcore.com/project/ipv4ec/en-us/index.html
20:49:38 <elliott> 11:46:19 <fizzie> For some reason I kind-of like the idea of using the "option key" symbol for if -- that is, ⌥ -- but it's really obscure.
20:49:41 <elliott> fizzie: Not among Mac users.
20:52:49 <Ilari> elliott: What you get there as number of IP addresses? :-)
20:53:03 <elliott> Ilari: Hm?
20:53:09 <elliott> Oh, on that page?
20:53:18 <elliott> I get 222,650
20:53:21 <elliott> IPv4s
20:53:23 <elliott> counting down rapidly of course.
20:53:30 <elliott> I'm in GMT.
20:53:32 <elliott> *UTC
20:53:42 <Ilari> Ah... So it is apparently just midnight local timezone...
20:54:24 <elliott> 14:15:04 <fizzie> Allocating one /47 per second would mean a total exhaustion in just 4.5 million years. Worrisome.
20:54:25 <elliott> :D
20:55:15 <olsner> I assume you've already discussed the news at length, but "All remaining allocatable IPv4s would now fit into a /9 prefix"
20:55:42 <Ilari> Err... What?
20:57:09 <Ilari> Isn't there about 22x/8s of total free IPv4 space? That doesn't fit in /4...
20:58:35 <Ilari> (the sum of all RIR and IANA pools, minus known reservations)
21:01:03 <olsner> I'm not entirely sure where those numbers come from :)
21:01:09 <elliott> hmm, now I'm wondering how to represnt function objects like this
21:01:21 <olsner> I guess it comes down to defining "allocatable"
21:02:40 <elliott> 16:20:41 <fizzie> ais523: Yeah, the main complaint about SVN I've heard from elliott is "it's supposed to be 'CVS done right', which is impossible".
21:02:40 <elliott> 16:25:09 <ais523_> I thought that was a Linus Torvalds quote/misquote?
21:02:46 <elliott> quote, yes, but it's not exactly a hard opinion to formulate
21:03:20 <olsner> torvalds expressed it with more vitriol than that
21:03:27 -!- hagb4rd has joined.
21:03:47 <elliott> IIRC no that was the exact quote, plus some extra
21:04:01 <elliott> "When I say I hate CVS with a passion, I have to also say that if there are any SVN (Subversion) users in the audience, you might want to leave. Because my hatred of CVS has meant that I see Subversion as being the most pointless project ever started. The slogan of Subversion for a while was "CVS done right", or something like that, and if you start with that kind of slogan, there's nowhere you can go. There is no way to do CVS right."
21:04:07 <elliott> So, with enough [...]s, the quote is accurate. :p
21:04:17 <olsner> ah, right :)
21:04:25 <hagb4rd> buenas
21:04:44 <olsner> I seem to recall him calling everyone on the svn project idiots as well
21:04:55 <olsner> but maybe it was more implied than literal
21:06:02 <hagb4rd> do you prefer an alternative cvs solution?
21:06:10 <cheater00> http://tinyurl.com/6a8ezpn
21:06:13 <hagb4rd> or none at all
21:06:32 <olsner> the final cvs solution, perhaps
21:06:51 <hagb4rd> sounds apocalyptic
21:07:22 <olsner> only for CVS, for everyone else it's more of an epiphany
21:07:50 <elliott> scapegoat!
21:07:54 <Vorpal> I looked a bit at DF. People compared it with minecraft. However it reminds me of nethack more (though not in genre), but it looks harder.
21:08:02 <olsner> elliott: what is that scapegoat thing?
21:08:04 <elliott> Vorpal: No, it has strong similarities to Minecraft.
21:08:16 <olsner> plz to explain me it
21:08:18 <Vorpal> elliott, but is it harder than nethack?
21:08:19 <elliott> Vorpal: For instance, a large part of the game is mining ore, which you can melt, and then make into pickaxes.
21:08:44 <elliott> Well, "harder"; it's certainly much, much deeper. I think it's not so hard to keep a fortress going after you've played for a while, but doing interesting things certainly doesn't look too safe.
21:08:53 <elliott> olsner: well you see, it's a version control system based on BLAME.
21:08:54 <elliott> any questions?
21:09:17 <elliott> Vorpal: Of course you do it all indirectly with dwarves, but they're stupid enough that you basically manually hand-hold them through it.
21:09:35 <Vorpal> elliott, so like minecraft with a hundred pickaxes at once?
21:10:02 <olsner> elliott: Be Lame, gotcha
21:10:07 <elliott> olsner: wat
21:10:09 <elliott> Vorpal: I don't know how practical coordinating a hundred dwarves to mine would be.
21:10:32 <hagb4rd> ->>see wow
21:10:41 <olsner> elliott: BLAME, BLame, B Lame, Be Lame
21:10:50 <Vorpal> elliott, isn't that what DF is about?
21:11:05 <elliott> Vorpal: I think keeping the dwarves alive is what it's about. :p
21:11:15 <elliott> Phantom_Hoover read that long Let's Play (although old; of the 2D version), ask him.
21:11:19 <Vorpal> elliott, so what is an usual population?
21:11:22 <elliott> Phantom_Hoover read that long Let's Play (although old; of the 2D version), ask him.
21:11:27 <elliott> I haven't actually played.
21:11:29 <Phantom_Hoover> elliott, what?
21:11:31 <Vorpal> elliott, also does DF have any easy mode so you can learn the damn gameplay ?
21:11:38 <elliott> I got scared off when the initial screen had an awful lot of characters and many, many menu items.
21:11:44 <Vorpal> elliott, haha
21:11:51 <Phantom_Hoover> Oh, right.
21:12:00 <olsner> elliott: no but seriously, what's BLAME?
21:12:06 <Vorpal> elliott, 2D version?
21:12:06 <elliott> olsner: Blame.
21:12:11 <elliott> Vorpal: It used to be 2D.
21:12:16 <olsner> oh, the word?
21:12:17 <Vorpal> elliott, what is it now then
21:12:19 <elliott> Vorpal: Now it's 3D displayed in cross-section 2D.
21:12:23 <elliott> olsner: Yes. It's based on blame.
21:12:24 <Phantom_Hoover> Vorpal, Boatmurdered had a population of around 100 at its peak, but it wasn't exactly a pinnacle of competent management.
21:12:29 <Vorpal> elliott, oh I see
21:12:42 <Vorpal> Phantom_Hoover, ah
21:12:49 <Phantom_Hoover> elliott, AFAIK it's always been 3D.
21:12:49 <elliott> Vorpal: Incidentally, the largest world it will generate is less than 300x300. :p
21:12:53 <elliott> Phantom_Hoover: Not true.
21:12:57 <olsner> elliott: hmm, ok... so what does that mean?
21:12:59 <elliott> Phantom_Hoover: Boatmurdered was done with the 2D version.
21:13:06 <elliott> olsner: Basically, every patch is done in terms of other patch.
21:13:17 <Phantom_Hoover> elliott, hm. But they had mines, which aren't exactly possible in 2D.
21:13:18 <elliott> olsner: An example change is "insert STRING between CHANGE and CHANGE", where each CHANGE is the hash of another change.
21:13:28 <elliott> olsner: The version control system keeps track of what change created which lines.
21:13:30 -!- impomatic has quit (Quit: http://retroprogramming.com).
21:13:30 <Vorpal> Phantom_Hoover, is there any sort of easy mode so you can learn the game mechanics without caring about monsters. Kind of like nethacks's explore mode
21:13:31 <Vorpal> or such
21:13:38 <elliott> Phantom_Hoover: Well, that's what they were.
21:13:41 <Phantom_Hoover> Vorpal, I don't know.
21:13:43 <elliott> Dwarf Fortress initially supported 2D landscapes only, with X and Y axes corresponding to the four cardinal directions. Later versions added a Z axis – multilayered maps – while retaining two-dimensional graphical representation. This allows for geographic features like hills, mountains, and chasms and player-created features like multilevel fortresses, waterfalls, above-ground towers, elaborate deathtraps, and pits.
21:13:46 <elliott> Vorpal: No.
21:13:46 <Vorpal> Phantom_Hoover, ah okay
21:13:51 <Vorpal> elliott, gah :/
21:13:56 <elliott> Vorpal: Man up and play the game properly. :p
21:14:06 <elliott> Vorpal: This is the philosophy:
21:14:10 <elliott> Losing is fun!
21:14:10 <elliott> Either way, it keeps you busy.
21:14:10 <elliott> There is no internal end point, single goal, final Easter egg or "You Win!" announcement in Dwarf Fortress. Therefore, eventually, almost every fortress will fall. The only ones that don't tend to be very conservative and very boring—and what fun is that? Therefore, DF = losing /\ DF = fun => losing = fun, and that's okay! It's a game philosophy, so embrace it, own it, and have fun with it!
21:14:10 <elliott> Most new players will lose their first few forts sooner rather than later; when you lose a fortress, don't feel like you don't understand the game. Dwarf Fortress has a steep learning curve, and part of the process (and fun!) is discovering things for yourself. However, this Wiki serves as an excellent place to speed up the learning process.
21:14:13 <elliott> If you lose, you can always reclaim fortress or go visit it in adventurer mode.
21:14:15 <elliott> If you're looking for more ways to test yourself, try either the mega construction or the Challenges articles.
21:14:20 <elliott> http://df.magmawiki.com/index.php/DF2010:Losing
21:14:41 <Vorpal> heh
21:15:00 <elliott> Having said that, I do want to create my own MC-esque game now...
21:15:09 <Vorpal> elliott, oh?
21:15:12 <elliott> I have figured out the most inane way to make the game difficult ever.
21:15:28 <elliott> Specifically, a game mechanic that means that you absolutely cannot start a reasonable mine until you do a LOT of things.
21:15:35 <Phantom_Hoover> elliott, if rand() < 0.9: lose()?
21:15:43 <elliott> Nope.
21:15:45 <elliott> Way better.
21:15:48 <olsner> elliott: I see, I think... so do you group those patches into things like files and commits afterwards?
21:16:07 <elliott> *You can only mine the block in front of you or above you*. Not downwards. To make a mine, you have to excavate tunnels with dynamite.
21:16:15 <elliott> To get dynamite, you need expensive materials... expensive materials that you get from mining.
21:16:29 <elliott> To get those materials, you make *animals that dig* follow you into the mine, and hope they dig good paths.
21:16:40 <elliott> To get the animals, you need, e.g. a dog, to sniff them out, and food, to make them follow.
21:16:41 <hagb4rd> lol
21:16:41 <elliott> To get a dog ...
21:17:00 <elliott> olsner: Erm, no. But a commit is just a patch.
21:17:11 <elliott> olsner: Specifically, there is a type of patch called a changeset, that is just a set of other patches.
21:17:22 <elliott> olsner: They're applied in the order of dependencies (i.e. if p1 depends on p2, p2 is applied before p1).
21:17:32 <elliott> olsner: To add a line to a blank file, you do:
21:17:39 <elliott> Insert "hello world" (StartOfFile FILEHASH) (EndOfFile FILEHASH)
21:17:53 <elliott> olsner: Each file has its own start-of-file/end-of-file patches.
21:18:19 <olsner> how do you create the file?
21:18:26 <elliott> olsner: (A file itself is referenced in the same way, by blaming a patch: the hash of the change that added the file to its directory.)
21:18:37 <elliott> (The permissible patches working on directories are basically like those on files, except they don't involve order.)
21:18:37 <hagb4rd> basic idea is not to save complete files but only the changes made
21:19:10 <elliott> (so there's "Insert FILENAME which is a [file|directory] into DIRECTORY", where DIRECTORY has to refer to an Insert patches that "is a directory".)
21:19:18 <elliott> (and also "RootDirectory", which is the patch you start off with.)
21:19:40 <hagb4rd> yes.. patch fits this issue
21:19:47 <hagb4rd> or sth
21:21:45 <Ilari> Heh... The amount of addreesses this gives would already fit into /17...
21:22:09 <olsner> and the current state of a (branch|repository) is just a single changeset that depends on a bunch of other changesets?
21:22:55 <olsner> is there any kind of branching support?
21:23:05 <elliott> olsner: well, it's more like a set of changes (otherwise i think you could technically end up with a repository with only one file as a freak accident)
21:23:07 <elliott> but pretty much
21:23:11 <elliott> olsner: yes, there is
21:23:30 <elliott> olsner: if two changes conflict, that's an automatic branch right there, because you can either have one or the other
21:23:38 <elliott> and you can also add branches specifically; ais523 can explain more when he's here
21:23:53 <elliott> olsner: the advantage of blame is that it makes very accurate merging *very* easy to implement
21:24:05 <elliott> olsner: and also basically eliminates fake conflicts... but also adds more conflicts that aren't caught by other VCSes
21:24:34 <elliott> olsner: it's what ais come up with after learning that darcs' merging model was insane :P
21:24:47 <olsner> designed to be even more insane? :P
21:24:54 <elliott> olsner: no, this is perfectly sane
21:25:00 <elliott> darcs' is insane in the "makes no sense" way
21:25:23 <elliott> I forget the name but the main TAEB guy looked into patch theory and concluded that it was a load of twaddle and that the merging algorithm didn't make any sense at all
21:25:52 <olsner> Tactical Amulet Extraction Bot?
21:26:54 <elliott> olsner: yes
21:27:58 <olsner> so I guess the guy you're talking about is sorear which is short for a name I don't recall?
21:28:10 <oerjan> <elliott> Having said that, I do want to create my own MC-esque game now... <-- /me read that as M.C. Escher
21:28:18 <elliott> oerjan: that too :D
21:28:29 <elliott> Phantom_Hoover: Vorpal: insufficient commenting on how perverse my evil early-game idea is
21:29:12 <Phantom_Hoover> elliott, oerjan, CLEARLY THIS IS A JOB FOR NUKERAY
21:29:39 <Vorpal> elliott, night →
21:29:56 <elliott> Phantom_Hoover: wat
21:30:02 <elliott> Vorpal: THAT'S NOT A COMMENT
21:30:43 <elliott> Vorpal: Have you updated mcmap, btw?
21:31:06 <Phantom_Hoover> elliott, Nukeray, a.k.a. the non-Euclidean raytracer that I have wanted to do for ages.
21:32:18 <oerjan> yay
21:32:42 <Ilari> /18...
21:38:58 <Ilari> /19...
21:40:25 <elliott> DUN DUN DUUUUUUUUUUUN
21:40:29 <elliott> oerjan: ?
21:42:07 <Ilari> /20...
21:43:42 <Ilari> /21...
21:44:29 <Ilari> /22...
21:44:54 <Ilari> /23...
21:45:04 <elliott> /99999
21:46:07 <Ilari> Num of IP addresses at 0. Estimated days to x-day... 1...
21:47:15 <elliott> Ilari: wat
21:47:55 <Ilari> Reloaded the page, it estimates X-day today...
21:49:36 <olsner> Ilari: which page btw?
21:51:26 <Ilari> http://inetcore.com/project/ipv4ec/en-us/index.html ... But apparently it uses timezones...
21:52:38 <olsner> oh, so that's why you're already out while I still have 68k addresses on the counter?
21:53:49 -!- BeholdMyGlory has joined.
21:53:52 -!- BeholdMyGlory has quit (Changing host).
21:53:52 -!- BeholdMyGlory has joined.
21:54:08 <Ilari> olsner: UTC+1h?
21:54:20 -!- Behold has quit (Read error: Operation timed out).
21:54:31 <olsner> Ilari: something like that, it's 23:09 here
21:54:52 <Phantom_Hoover> Vorpal, incidentally, DF has an option in world generation for natural savagery and number of beasts.
21:54:58 <Phantom_Hoover> There's your difficulty parameter.
21:57:51 -!- Mathnerd314 has joined.
21:58:56 <elliott> Phantom_Hoover: WHAT DO YOU THINK OF MY EARLY-GAME CRAZY
21:59:15 <Phantom_Hoover> Pretty goddamn crazy.
21:59:26 <Phantom_Hoover> Although Escherian geometry would make it even better.
21:59:26 <elliott> Phantom_Hoover: But awesome.
21:59:30 <elliott> Phantom_Hoover: FFFFF
21:59:34 <elliott> You are so lame.
21:59:59 <elliott> Phantom_Hoover: Come on, having to get a pet, use it to find digging animals, lure them with food into a cave, hope they dig in the right places, and hope it leads to useful minerals without eating them?
22:00:08 <elliott> At the START OF THE GAME?
22:00:47 <oerjan> <elliott> oerjan: ? <-- non-Euclidean raytracer.
22:03:36 -!- Lymia_ has joined.
22:06:25 -!- Lymia has quit (Read error: No route to host).
22:08:43 <Phantom_Hoover> oerjan, it kind of foundered.
22:08:56 <Phantom_Hoover> Mainly because I don't know how to trace geodesics.
22:10:28 <elliott> Output XXXXX UTF-16 characters beginning at DP. (Note that a UTF-16 character is the same length in digits as an instruction.)
22:10:31 <elliott> quintopia: false
22:11:57 <quintopia> why?
22:11:59 <quintopia> i'll fix it
22:12:12 <elliott> quintopia: because unicode takes up more than 16 bits
22:12:25 <elliott> only UTF-32 can encode every codepoint in one fixed size.
22:12:32 <elliott> Output XXXXX UTF-16 characters beginning at DP. (Note that a UTF-16 character is the same length in digits as an instruction.)
22:12:34 <elliott> erm
22:12:36 <quintopia> well that's stupid
22:12:37 <elliott> UTF-16 (16-bit Unicode Transformation Format) is a character encoding for Unicode capable of encoding 1,112,064 numbers (called code points) in the Unicode code space from 0 to 0x10FFFF. It produces a variable-length result of either one or two 16-bit code units per code point.
22:12:49 <elliott> quintopia: UTF-16 is stupid, yes, but it's mainly "backwards compat"
22:12:55 <elliott> originally unicode was 16-bit
22:12:57 <elliott> and UTF-16 was called UCS-2
22:13:03 <elliott> but then it got expanded to ~21 bits IIRC
22:13:07 <elliott> and UTF-16 was created based on UCS2
22:13:25 <quintopia> so if changed that to say UCS2, it'd be right? :P
22:13:59 <elliott> quintopia: no.
22:14:05 <quintopia> eh, i could also just write "where possible"
22:14:08 <elliott> UCS-2 is obsolete and cannot encode any even vaguely recent Unicode version.
22:14:10 -!- yiyus has quit (Ping timeout: 272 seconds).
22:14:26 <elliott> U+64321 in utf-16: 0xD950, 0xDF21
22:14:52 <elliott> quintopia: just say "Output XXXXX UTF-16 code units beginning at DP."
22:14:57 <elliott> quintopia: and remove the note
22:14:57 <quintopia> right
22:15:01 <quintopia> that's what i'm thinking
22:15:03 <quintopia> also
22:15:07 <quintopia> you are looking at it
22:15:09 <elliott> quintopia: code units meaning, U+64321 would have XXXXX=2
22:15:11 <quintopia> edit it for me and look smart
22:15:18 <elliott> no i'm lazy
22:15:35 <quintopia> oh okay
22:16:40 <quintopia> elliott: or i could just remove the note.
22:17:01 <quintopia> so if you start a 2 code point character it finishes it for you :P
22:17:16 <elliott> quintopia: no, you have to s/characters/code units/, UTF-16 doesn't define what a character is anyway
22:17:22 <elliott> and "code points" would mean that e.g. length=1 could scan /two/ bytes ahead
22:17:28 <elliott> your impl would have to be UTF-16 knowledgeable
22:17:30 <elliott> just saying "code units" is better
22:17:39 <elliott> because things that get encoded into two 16-bit values just have length 2
22:17:41 <elliott> and that's simpler
22:17:48 <quintopia> yes
22:17:58 <quintopia> a UTF-16 knowledgeable impl
22:18:00 <quintopia> exactly
22:18:19 <elliott> quintopia: lame
22:18:20 <elliott> do what i said
22:18:21 <elliott> simpler
22:18:25 <quintopia> although i'm not sure what you said
22:18:28 <quintopia> or why
22:18:34 <quintopia> just now
22:18:38 <quintopia> say it again in english
22:19:13 -!- Phantom_Hoover has quit (Remote host closed the connection).
22:19:30 <elliott> <elliott> quintopia: just say "Output XXXXX UTF-16 code units beginning at DP."
22:19:30 <elliott> <elliott> quintopia: and remove the note
22:20:05 <quintopia> but what happens when it outputs the first half of a double length character as the last unit?
22:21:23 <elliott> quintopia: shit happens.
22:21:29 <elliott> It doesn't really matter. :p
22:21:37 -!- augur has quit (Remote host closed the connection).
22:21:42 <quintopia> FINE
22:24:05 -!- MigoMipo has quit (Read error: Connection reset by peer).
22:25:46 <elliott> quintopia: I highly doubt that language is TC.
22:25:58 <elliott> I don't see any way to do anything conditionally.
22:25:59 <elliott> Well.
22:26:01 <elliott> Not highly doubt.
22:26:03 <elliott> But it's very non-obvious.
22:26:13 -!- Behold has joined.
22:27:21 <quintopia> elliott: well, let me know if you come up with a proof either way
22:27:31 <elliott> That sounds like work.
22:27:56 <quintopia> not that you need to actually think about it
22:28:12 <quintopia> if it comes to you in a gestalt, all you need do is describe the proof and i will fill in the details
22:28:56 <elliott> that doesn't happen to me.
22:29:16 -!- BeholdMyGlory has quit (Ping timeout: 255 seconds).
22:31:16 <quintopia> in any case, i think conditionals are possible (if difficult) by combining TRANSFORM with JUMP
22:31:24 -!- yiyus has joined.
22:31:42 <quintopia> may even be possible without TRANSFORM, iunno
22:35:21 <Ilari> 039/8 APNIC 2011-01 whois.apnic.net ALLOCATED
22:35:29 <Ilari> 106/8 APNIC 2011-01 whois.apnic.net ALLOCATED
22:36:18 <Ilari> 102, 103, 104, 179 and 185 are still marked as unallocated.
22:36:44 <oerjan> Ilari: WAT
22:37:02 <oerjan> just now?
22:37:20 <elliott> wat
22:37:30 <elliott> exciting
22:37:39 <elliott> oerjan: well it was inevitable that it would happen before the end of the month.
22:37:48 <elliott> so it's not _too_ surprising
22:42:01 <olsner> so are we officially out of IP:s yet? :)
22:45:30 <Ilari> Nope... But the IANA has officially entered Exhaustion Phase
22:48:52 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
22:53:47 <quintopia> oh hurray
22:54:46 <Ilari> No further normal IPv4 allocations to RIRs will occur. There will still be 1x/8 handed to each RIR, and that's it.
22:55:05 <elliott> woooo
22:55:10 <elliott> let's do a party
22:55:18 <Ilari> Wonder which RIR is most depleted in IPv6 space...
22:55:23 <Ilari> *the most depleted
22:56:04 <elliott> so Ilari how long until rir depletion :)
22:56:15 -!- BeholdMyGlory has joined.
22:56:45 <Ilari> Very difficult to say...
22:57:00 <elliott> what do the models say? not that i expect them to be very accurate at this point
22:58:07 <Ilari> Models say end September... But those models may be hopelessly optimistic.
22:58:32 <elliott> Ilari: RIR depletion is not even the end, IIRC some university with an /8 says they'll donate it
22:58:38 <elliott> and probably many others with similarly huge allocations will
22:59:24 -!- Behold has quit (Ping timeout: 246 seconds).
23:00:56 -!- Sgeo has joined.
23:03:17 -!- Lymia_ has changed nick to Lymia.
23:03:18 -!- Lymia has quit (Changing host).
23:03:18 -!- Lymia has joined.
23:04:00 <elliott> https://chrome.google.com/webstore/detail/hhnjdplhmcnkiecampfdgfjilccfpfoe ;; didn't expect that from Google...
23:07:14 -!- TLUL has joined.
23:10:54 <Ilari> IPv6 usages: AFRINIC: 0.016%, ARIN: 1.5%, APNIC: 2.6%, RIPE: 3.4%, LACNIC: 6.3%.
23:11:43 <Ilari> So even the most depleted RIR (in terms of IPv6 space) still has >90% of /12 available...
23:11:44 <elliott> WHOO BOY LACNIC
23:12:02 -!- augur has joined.
23:12:11 <Sgeo> Depleted? IPv6?
23:12:26 <elliott> Yes.
23:12:36 -!- elliott has set topic: IPv6 has been depleted, tell your friends | http://esolangs.org/ | | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
23:13:02 <Ilari> One of the allocations from LACNIC is a IPv6 /16(!).
23:13:11 -!- nddrylliog has joined.
23:13:30 <elliott> Ilari: what's that, like, seventy gajillion addresses? :P
23:13:36 <oerjan> *facepalm*
23:13:47 <elliott> oerjan: wat
23:13:52 <elliott> oerjan: topic is not mistake, it is troll
23:13:59 <oerjan> I KNOW THAT
23:14:02 <elliott> :P
23:14:10 <oerjan> _STILL_ FACEPALM
23:14:12 <olsner> 5*10^33 addresses?
23:14:22 <Ilari> It is apparently the largest IPv6 allocation ever made by a RIR...
23:15:02 <elliott> it's actually 4 addresses, /16 is a special case
23:15:02 <Ilari> Seems so (5*10^33).
23:15:04 <elliott> just to confuse everyone
23:15:47 <Ilari> OTOH, what it was allocated to: The main LIR of Brazil...
23:16:17 <Ilari> Those guys need metric shitton of address space...
23:16:53 -!- Behold has joined.
23:17:25 <Ilari> 45% of entiere allocated IPv6 address space is marked as allocated to brazil...
23:18:08 <olsner> We demand: ONE HALF INTERNET
23:18:20 <elliott> :D
23:18:39 <nddrylliog> one half? are you kidding? I won't settle for less than OVER NINE THOUSAND.
23:18:52 <elliott> olsner: unfortunately they only got 9/20ths.
23:19:04 * elliott tells oerjan to swat nddrylliog
23:19:16 * oerjan swats elliott -----###
23:19:25 <oerjan> SORRY MISSED
23:19:28 <nddrylliog> so much for a warm welcome
23:20:10 -!- BeholdMyGlory has quit (Ping timeout: 255 seconds).
23:20:33 <olsner> five thousand quadrillion quadrillion addresses
23:20:42 <pikhq> Ilari: Any idea when the final IANA assignments go out?
23:20:57 <nddrylliog> http://www.wolframalpha.com/input/?i=number+of+IPv6+adresses <- fail
23:21:24 <cheater00> http://www.4chan.org/banned
23:21:25 <cheater00> :(
23:21:29 <pikhq> Hmm. It's 15:35 at IANA.
23:21:45 <pikhq> It would be entirely plausible that they do it today.
23:21:57 <olsner> or just 5000 quintillion, if you're using "long scale" for large numbers, rather than "short scale"
23:22:18 <cheater00> nddrylliog: why are you interested in dresses?
23:23:04 -!- oerjan has quit (Quit: Later).
23:23:51 <pikhq> If not today, then tomorrow, I guess?
23:24:13 <nddrylliog> cheater00, oh just a particular dress.
23:25:32 <nddrylliog> anyway, since we're off-topic: does anyone have an opinion on gnome-xchat? it sounds like a very gnome program - take the original, remove features, hinder settings, there you go.
23:25:42 <elliott> nddrylliog: It's very unmaintained.
23:27:18 <nddrylliog> right. that explains it.
23:27:50 <nddrylliog> ah, anyone has a name idea for that low-level declarative programming language I'm playing with?
23:28:13 <Sgeo> X
23:28:35 <Sgeo> Because the world needs more single letter language names
23:28:42 <nddrylliog> "About 3,650,000,000 results"
23:28:46 <elliott> nddrylliog: it's not really that low level. :p
23:29:02 <elliott> Call it "crap", I bet nobody has ever called their programming language the crap programming language before.
23:29:12 <nddrylliog> elliott, yeah, indeed. The fact that you can write stuff like ([e1, e2] # self | e1.next == e2) => e1 == e2.prev is pretty neat
23:29:20 <Sgeo> elliott, that language you like
23:29:22 <Sgeo> Merd
23:29:27 <elliott> Sgeo: That's merd, not crap.
23:29:42 <elliott> nddrylliog: Funny, in my programming language you can write "Sort the list of integers given on the command line." which is also pretty neat. :p
23:29:50 <nddrylliog> elliott, isn't it? :D
23:29:56 <nddrylliog> I never said it would compile
23:30:02 <elliott> :D
23:30:14 * Sgeo hits elliott with an Osmosian
23:30:26 <elliott> nddrylliog: Call it Oracle-Originating Compiler, because that's the only place you're going to find it.
23:30:31 <nddrylliog> ooc.
23:30:32 <elliott> You could even abbreviate it and get a nice TLA.
23:30:36 <nddrylliog> great.
23:30:36 <elliott> HARDY HAR HAR
23:30:37 <elliott> DO YOU SEE
23:30:38 <elliott> WHAT
23:30:38 <elliott> I
23:30:38 <elliott> DID
23:30:41 <elliott> THERE
23:30:48 <elliott> I'm sorry, forgive me.
23:30:55 <Sgeo> Call it Go
23:31:00 <nddrylliog> http://uncyclopedia.wikia.com/wiki/Og_(programming_language)
23:31:03 -!- TLUL has quit (Ping timeout: 240 seconds).
23:31:08 <elliott> call it nddrylliog
23:31:26 <Sgeo> Call it Stackoverflow
23:31:41 -!- lambdabot has quit (Ping timeout: 276 seconds).
23:31:43 <Sgeo> Then declare nomic war
23:31:43 <elliott> http://uncyclopedia.wikia.com/wiki/Og_(programming_language) <-- I like how this is just a thinly-veiled rant made by someone who really hates Go
23:31:47 <nddrylliog> I'd like to somehow make a reference to the fact that it's somehow impossible to implement.
23:31:54 <elliott> They could at least try and use the letter-swap for humour.
23:32:03 <nddrylliog> "The syntax of Og is pretty much the same old crap that we have been using for over 40 years which mostly comes from the C language. Blocks of code are surrounded with the usual stupid curly braces, it has the usual common control flaw structures including for, switch, if, and maybe even the universally despised go to" <- Hell yeah.
23:33:14 <Sgeo> They don't even mention magical make()?
23:33:16 <olsner> nddrylliog: you could call it ž
23:33:16 <olsner> (BARRIER CONTRACEPTIVE)
23:33:30 <elliott> Sgeo _really_ hates magic.
23:33:49 <Sgeo> No. I just hate magic I can't use for myself.
23:34:08 <nddrylliog> hey, I reinvented make() and go() in pure ooc in a few minutes
23:34:23 <nddrylliog> and then I called off the Go guys in my talk, showing how I reimplemented their so-called novelties on top of my language
23:34:23 <olsner> hmm, not sure if that came across right, it's U+1621E
23:34:46 <nddrylliog> olsner, yeah.. I'm not sure about non-ASCII stuff. Well, I'm french and all but.. yeah, no.
23:34:49 <Sgeo> nddrylliog, the point of integrating those things in an stdlib is so that everyone uses it
23:34:58 <elliott> nddrylliog: Ignore Sgeo. :p
23:35:03 <nddrylliog> Sgeo, oh it's in the ooc standard lib now. Which means everyone is free not to use it.
23:35:03 <Sgeo> Although go and make() aren't stdlib level
23:35:03 <olsner> nddrylliog: seriously, choose one really obscure incode character and call it that
23:35:14 <olsner> your users have to find a special font to even read the name, it's awesome
23:35:21 <elliott> nddrylliog: call it Æñëßŋ
23:35:26 <elliott> pronounced "see plus plus"
23:35:32 <nddrylliog> olsner, I'd call it ಠ_ಠ if I could.
23:35:35 <olsner> then invent your own symbolic language in which the manual is written
23:35:46 <elliott> nddrylliog: call it Magic
23:35:48 <elliott> after the compiler
23:35:55 * Sgeo is watching Hikaru no Go
23:35:56 <nddrylliog> I guess asking #esoteric for help really is not the best idea
23:36:11 <nddrylliog> except, you know, for the fun factor
23:36:21 <Sgeo> nddrylliog, put it on the wiki
23:36:21 <elliott> nddrylliog: I'm trying here!
23:36:27 <Sgeo> Then we can come up with a name
23:36:27 <olsner> you can put your symbol language in one of the private use ranges of unicode and make your own font for it
23:36:36 <Sgeo> (I just want the docs but am too lazy to logread
23:36:38 <Sgeo> )
23:36:40 <nddrylliog> http://www.producemagic.com/Produce-Accounting-Software-Content.asp?CategoryID=5&ContentID=202 <- OH. MY. GOD. IT'S ALIVE.
23:36:45 <elliott> nddrylliog: Call it ⅛€¬¹.
23:37:03 <olsner> "pronounced Linenoise"
23:37:08 <Sgeo> <Ami> I'm tracking 2 nicks. Both nicks are for the same person.
23:37:08 <nddrylliog> elliott, one eighth of euros weird hyphen upper one what?
23:37:27 <nddrylliog> Sgeo, yeah as soon as I have half a decent spec/tutorial/examples I'll put it on the wiki
23:37:45 <elliott> nddrylliog: Yes, exactly.
23:38:39 <nddrylliog> ooooh btw, forgot to ask - will any of you guys be at FOSDEM this week-end?
23:39:14 <elliott> don't be silly, it's probably populated with people who actually program and such
23:39:19 <elliott> we can't be having that
23:39:25 <elliott> they carry cooties
23:39:46 <nddrylliog> VDOEESINSSO ?
23:40:03 <Deewiant> No, VFOEESINSSO.
23:40:16 <nddrylliog> huh, right
23:40:25 <nddrylliog> the thing is, I really like the name (⅛€¬¹). I'll probably use it somewhere.
23:40:55 <elliott> You can even pronounce it nicely: "one eighth of a euro, not ... superscript ... one".
23:42:13 <olsner> it's a splendid name for an esolang it is
23:43:36 <nddrylliog> it'd need a... "usable" name for folder names and such, though
23:43:55 <olsner> one8thenot1
23:44:08 <nddrylliog> hey one8thenot1 is actually next to usable :)
23:44:24 <olsner> it reads as one-eight-the-not-one though
23:44:43 <olsner> one8th€not1 perhaps
23:45:55 <nddrylliog> ascii please
23:46:13 <elliott> nddrylliog: call it Point.
23:46:17 <nddrylliog> Now I'm feeling guilty about using braces in a programming language. should I?
23:46:23 <elliott> ABSOLUTELY
23:46:29 <elliott> use
23:46:35 <elliott> “ ”
23:46:36 <elliott> instead
23:46:39 <elliott> you can even nest them
23:46:43 <nddrylliog> bahh I could go S-expressions instead, but..
23:46:48 <elliott> “ ”
23:47:00 <Deewiant> « »
23:47:07 <elliott> no
23:47:08 <elliott> “ ”
23:47:15 -!- FireFly has quit (Quit: swatted to death).
23:47:15 <nddrylliog> actually, I couldn't go for S-expressions, () is already meaningful
23:47:17 <olsner> ascii? that's a standard from 1963, you might as well try and be compatible with the apollo guidance computer
23:49:54 <elliott> :D
23:49:58 <elliott> you should be!
23:50:07 <elliott> nddrylliog: just have all the syntax totally redefinable. at runtime
23:50:26 <Lymia> Why are we talking about Lisp in #esoteric?
23:50:33 <elliott> we're not
23:50:39 <olsner> Lymia: it's not us! it's nddrylliog
23:50:40 <nddrylliog> we're not
23:50:45 <Lymia> It would fi- *knived*
23:51:14 <quintopia> what is going on so much color i agh
23:51:20 <elliott> quintopia: wat
23:51:26 <olsner> he may have merely been talking about S-expressions though
23:51:44 <elliott> moar liek SEXpressions
23:51:46 <quintopia> usually all the nicks are green because elliott is the only one talking...the activity is too much to handle
23:51:49 <olsner> elliott: maybe he in the, just like that
23:51:50 <elliott> :D
23:51:51 <quintopia> why is it popular
23:51:54 <quintopia> what happened
23:51:55 <elliott> rabble rabble rabble
23:51:56 <elliott> rabble rabble rabble
23:51:56 <elliott> rabble rabble rabble
23:51:56 <elliott> rabble rabble rabble
23:51:56 <elliott> rabble rabble rabble
23:51:56 <elliott> rabble rabble rabble
23:51:58 <elliott> rabble rabble rabble
23:52:00 <elliott> rabble rabble rabble
23:52:02 <elliott> rabble rabble rabble
23:52:04 <elliott> rabble rabble rabble
23:52:06 <elliott> rabble rabble rabble
23:52:08 <elliott> rabble rabble rabble
23:52:10 <elliott> rabble rabble rabble
23:52:10 <Lymia> `-`
23:52:12 <elliott> quintopia: is that better?
23:52:17 <quintopia> thx
23:52:19 * Lymia hides from the spam
23:52:22 <Lymia> Spam dosn't fix the problem!
23:52:29 <quintopia> it does tho
23:52:36 <quintopia> that or kicking people
23:52:42 <HackEgo> No output.
23:53:08 <olsner> "No output." the bot does not want you kicking anyone
23:53:10 * nddrylliog ducks
23:53:16 <quintopia> what was hackego showing up late for
23:53:26 <nddrylliog> "No output" is a terrible error message. Especially in bed.
23:54:08 <elliott> quintopia: lymia said "`-`" which is probably meant to be some sort of smiley
23:54:11 <elliott> except it just looks more like... uh
23:54:16 <elliott> a backtick, a hyphen and a backtick
23:54:18 <elliott> not a face
23:54:20 <quintopia> yeah
23:54:21 * Lymia cries
23:54:30 <quintopia> lymia: try ;_; for cyring
23:54:35 <quintopia> or crying even
23:54:55 <nddrylliog> crying for crying? that's crazy talk!
23:55:29 <quintopia> NO. ME CRAZY TALK. HE ASS HEAD.
23:57:10 <nddrylliog> so.. brace yourself
23:57:16 <nddrylliog> I give you: the singly-linked list: http://bpaste.net/show/13387/
23:57:36 <nddrylliog> and now... the doubly-linked list: http://bpaste.net/show/13388/
23:59:02 * quintopia ...doesn't die
23:59:10 * quintopia ...is severely underwhelmed
23:59:33 <elliott> nddrylliog your element thing doesn't work god damn :p
23:59:48 <nddrylliog> elliott, it is perfectly fine!
23:59:58 <elliott> isn't
←2011-01-30 2011-01-31 2011-02-01→ ↑2011 ↑all