00:04:33 <ihope> d(e^x) = e^x dx, indeed...
00:05:48 <oklopol> actually, that's not all that likely...
00:05:57 <oklopol> those aren't next to each other
00:05:59 <oerjan> you're so tired that your keyboard knows more math than you? :)
00:06:59 <oerjan> _bad_ keyboard, no, um, what kind of rewards do keyboards get anyway?
00:07:08 <oklopol> hah! and you thought i was tired... proved you wrong
00:07:24 -!- lament has set topic: dx = d(e^x)/e^x.
00:08:18 <oklopol> well... i kinda have to :|
00:08:33 <oerjan> hah, that's what they all say.
00:08:35 -!- lament has set topic: dx=d(e^x)/e^x | c=sqrt(e/m).
00:50:19 -!- kwertii has joined.
01:01:05 -!- Haikz has joined.
01:45:54 -!- Sgeo has joined.
02:30:20 -!- oerjan_ has joined.
02:31:07 -!- oerjan_ has quit (Client Quit).
02:31:16 -!- oerjan has quit (Remote closed the connection).
02:31:23 -!- oerjan has joined.
03:22:25 <bsmntbombdood> <ihope> What we really need is a language where most syntax constructs can be defined easily.
03:28:31 <pikhq> What we need is a language without much syntax. (like Lisp)
03:29:26 * oerjan bets pikhq is thinking of a language with 3 letters in its name
03:32:13 <pikhq> That's the other nice one.
03:32:58 -!- oerjan has quit ("Good night").
03:33:08 * pikhq can't help but think that either (+ 2 2) or + 2 2 is much nicer than defining some extra syntax for a *function*.
03:48:23 -!- revilodraw has joined.
03:49:04 -!- revilodraw has left (?).
04:27:04 -!- GregorR-L has joined.
04:52:48 -!- GreaseMonkey has joined.
05:16:44 -!- RodgerTheGreat has quit.
05:27:10 -!- nwf has joined.
05:51:22 -!- Figs has joined.
05:51:33 <Figs> you around? :P
05:52:33 -!- nwf has quit ("Lost terminal").
06:03:37 <Figs> did you get a chance to play through the rest?
06:03:42 <oklokok> after 30 hours awake, 6 hours of sleep just doesn't seem to be enough
06:04:15 <Figs> I tend to have about 18 hours up, 6 hours down
06:04:38 <oklokok> i haven't played after that, i was at a friend's :\ i'll try to play once i wake up or something, night now -->
06:04:42 <Figs> of those 18 hours or so up, usually at least 10 are online
06:04:52 -!- Figs has left (?).
06:06:15 -!- Sgeo has quit ("Ex-Chat").
06:27:09 -!- goban has joined.
06:32:43 -!- goban has quit (Read error: 104 (Connection reset by peer)).
06:36:10 -!- GregorR-L has quit (Read error: 110 (Connection timed out)).
06:42:38 -!- Arrogant has joined.
07:41:04 -!- GreaseMonkey has quit (Read error: 104 (Connection reset by peer)).
07:43:54 -!- Arrogant has quit ("Leaving").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:51:16 -!- Sukoshi has joined.
09:06:38 -!- jix has joined.
09:13:46 -!- kwertii has quit.
11:08:02 -!- ehird` has joined.
11:11:40 -!- ehird` has set topic: fib<-{=0=>0->=1=>1->$(-1)+$(-2)}.
11:11:49 <ehird`> since, apparently, this is #change_the_topic_to_something_random
11:30:05 <Haikz> That's good to know.
11:32:43 -!- Haikz has set topic: fib<-{=0=>0->=1=>1->$(-1)+$(-2)} // Happy birthday, Maria Filatova! Born in 1961, Maria is a retired soviet gymnast of great significance..
11:43:49 -!- ehird` has set topic: hello world.
12:05:19 -!- jix has quit (Nick collision from services.).
12:05:33 -!- jix has joined.
12:06:15 <ehird`> hmmmm .. lots of infinite loops should be easy to detect in the lambda calculus, no?
12:06:33 <ehird`> store a list of each stage of reduction, and if any frame repeats, it's an infinite loop so error out
12:06:47 <ehird`> doesn't solve the halting problem of course but it should catch lots of things
12:11:40 <oklokok> i had this dream my friend's mind was stuck in my brain and we took turns controlling my body
12:12:43 <oklokok> ehird`: yes, if same state occurs twice, it's an infinite loop... that's true for any language
12:13:01 <ehird`> oklokok, so why don't more languages error out on it? :)
12:13:17 <ehird`> an unconditional infinite loop without any I/O is useless
12:13:27 <ehird`> and there are plenty of io-less languages.
12:13:33 <oklokok> because lambda calculus is the only one where it's hard to make a program that has a complex state
12:14:52 <oklokok> you can just as well do that in brainfuck, every loop just stores a list of all states it's been in at the beginning of that loop
12:15:15 <oklokok> that will most likely be more efficient in finding loops
12:16:14 <ehird`> so why don't more languages do it i wonder.
12:16:19 <oklokok> because in lambda calculus, if 10 numbers of 5 digits each are passed around, that'd be depending on the representation 50 or something bytes
12:16:22 -!- blahbot` has joined.
12:16:28 <oklokok> whereas in brainfuck that'd be 5, always.
12:16:36 <ehird`> well, ram is plentiful
12:16:43 <ehird`> maybe the states could be gc'd
12:16:46 <oklokok> they don't do it since it sounds so easy to do in ski
12:17:16 <oklokok> with ski, even though people know it's tc, they often don't actually think of it as such
12:17:36 <oklokok> you need very complex stuff to actually utilize it's tcness
12:17:46 <ehird`> yeah, i'd like to see a turing machine in SKI
12:18:23 <oklokok> oerjan's done something pretty sick in it... may have been a ski interpreter in ski
12:19:24 <oklokok> http://home.nvg.org/~oerjan/esoteric/interpreter.unl
12:21:46 <oklokok> actually, unlambda is most likely actually one of the hardest languages to store state for, since simple rules usually lead to much bigger memory hogging
12:22:05 <oklokok> a high-level language would be much better at that
12:24:33 <oklokok> it's just if you try whether a language finds infinite loops, in c you do int i=1;while(i){i++;if(i==0)i=1;} or something creative "to bluff the infinite loop detector"
12:24:56 <oklokok> in unlambda you'll do siisii and hail at the clever bitch
12:25:05 <oklokok> wow it understood that's a loop
12:25:26 <oklokok> omg to me that's just a random bunch of letters and the interpreter knew it was an infinite loop
12:25:41 <oklokok> i'm gonna do one eating now.
12:29:32 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
12:29:34 <oklokok> states could be hashed, that's always a possibility
12:29:54 -!- ehird` has joined.
12:30:00 <oklokok> states could be hashed, that's always a possibility
12:30:10 <oklokok> but what do you mean garbage collected?
12:31:07 <oklokok> i know what the term means of course but what's it gonna help :)
12:32:33 <oklokok> it seems my parents implemented me some macaroni or something yesterday
12:32:37 <ehird`> parsing lambda calculus by hand isn't easy
12:32:40 <oklokok> cool, i can actually eat something
12:32:43 <ehird`> stupid "expr expr" grammars
12:33:41 <oklokok> it isn't easy because you have to handle large blocks at once as soon as you actually *do* something... but that's true of any tc language, once again :)
12:34:23 <ehird`> oklokok, well, for one thing
12:34:33 <ehird`> once you reduce a certain part of an expression you can trash all the hashes for it
12:34:44 <ehird`> every time you fully reduce anything you can get rid of the state history
12:35:01 <oklokok> yes, that is the exact same thing as having []
12:35:11 <ehird`> and, indeed, hashed states - but if a state isn't used for a certain amount of reductions, you can trash it
12:35:17 <oklokok> yes, that is the exact same thing as having []'s in brainfuck have their own state lists
12:36:08 <oklokok> you can't really trash anything, *any* sequence might occur again, later
12:36:15 <oklokok> since a lambda program has nothing but state
12:36:25 <oklokok> i mean, it has just one kind of state
12:36:42 <oklokok> that is a memory state, and can be completely changed
12:37:06 <oklokok> whereas in brainfuck you have two states, one of which actually does some discarding with no return possibility
12:37:24 <oklokok> memory state once again can't be gc'd in brainfuck either
12:37:26 -!- puzzlet_ has joined.
12:37:49 <ehird`> <oklokok> you can't really trash anything, *any* sequence might occur again, later <-- yes but you dont want to keep something that only appeared 10 reductions ago
12:38:26 <oklokok> what if the next s-combinator accurately replicates whatever was there 10 reductions ago?
12:38:49 <oklokok> then that same state will be discarded again if discarding rules are deterministic
12:39:19 <ehird`> i only mean ones from previous reductions
12:48:58 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
12:49:02 <ehird`> parsing left-recursive grammars is evil
12:51:12 <oklokok> well, math is left-recursive
12:51:26 <oklokok> any left-associative operators require left-recursion
12:53:04 <ehird`> i'm parsing \x.\y.\z.xyz as x(yz) not (xy)z, right now
12:53:47 <oklokok> well... why don't you make your notation tell how to parse it...
12:54:02 <oklokok> how'd you do (xy)z in that parsing?
12:54:51 <ehird`> oklokok, because i'm hand-coding this.
12:55:05 <ehird`> \xy.xy is being parsed as (\xy.x)y
12:55:09 <ehird`> which is ANNOYING MAXIMUM
12:56:23 <oklopol> how's the problem left-recursion=
12:57:13 <oklopol> use unlambda notation and you can have my ololobot code :)
12:58:48 <ehird`> well yeah, that's the thing i don't want to use unlambda notation
12:59:43 <ehird`> (\nfx.f((nf)x))(\fx.fx) looks nicer than `^n^f^x`$f``$n$f$x^f^x`$f$x
13:00:23 <oklopol> anyway, you take the first, and give it as arguments everything until the end.
13:00:35 <oklopol> and ta-da, both your things will work
13:00:53 <oklopol> ( will be recursed into, and parsed so that ) is the end
13:01:04 <oklopol> the upmost level has <eof> as )
13:15:34 <oklokok> (14:37:53) (ehird`) well, sure
13:15:35 <oklokok> (14:38:14) (ehird`) i only mean ones from previous reductions
13:15:41 <oklokok> what did you mean by this, actually, i know realize i didn't understand
13:15:59 <ehird`> once finishing a reduction, trash its states
13:16:16 <oklokok> every step in the program is a reduction
13:16:30 <oklokok> so basically you would just store 10 last states?
13:16:58 <ehird`> once you've done lots of reductions and a particular sub-expression is irreducable, you can forget the states for that subexpression
13:18:57 <oklokok> you mean, if a part in the state keeps unchanged, you can stop storing the whole state for that part separately, and instead just have a way to point to where that part was last in the program state?
13:19:29 <oklokok> s/ if a part in the state /if a part of the whole program state
13:20:55 -!- Baughn has quit (anthony.freenode.net irc.freenode.net).
13:20:55 -!- tokigun_ has quit (anthony.freenode.net irc.freenode.net).
13:22:41 -!- Baughn has joined.
13:22:41 -!- tokigun_ has joined.
13:24:37 * ehird` wonders why () don't work
13:24:48 <ehird`> (x) -> (apply "x" nil)
13:39:04 -!- oerjan has joined.
13:42:50 <oklopol> (i'd actually used your name if i were able to type that letter)
13:43:36 <oerjan> i actually couldn't see if you were typing my name since i am not UTF8-clean
14:03:03 * ehird` wonders why lambda calculus defies simple parsing
14:04:42 <oerjan> almost every programming language does, then.
14:06:28 <ehird`> well most languages do defy hand-parsing
14:06:37 <ehird`> especially goddamn left-associative languages!
14:07:19 <oerjan> actually it _is_ easy.
14:08:25 <oerjan> just keep an accumulating parameter
14:08:43 <ehird`> i've been trying to parse LC that only consists of single-character names, \x(... and more).y and (x)
14:10:27 <oklopol> ehird`: doesn't sound hard to do :|
14:10:38 <ehird`> oerjan, xy is application..
14:10:44 <ehird`> oklopol, sure - just tedious
14:11:03 <oklopol> i think it's < 15 lines in python
14:12:21 <ehird`> ~320 lines of ruby right now
14:12:44 <oerjan> something is very wrong there
14:13:19 <oerjan> i was about to say < 5 lines in Haskell :)
14:13:25 <oklopol> ruby is no ordinary language xD
14:14:25 <ehird`> haha, 320 lines would be insane!
14:14:31 <oklopol> -320 would've been more insane.
14:14:42 <ehird`> just make self-modifying code that removes characters
14:15:04 <ehird`> have the parser just take code from other bits of the program and remove characters (320 of them) until you get a parser.
14:15:07 <oerjan> "yes, lambda calculus is so easy to parse it actually shaves lines off your code"
14:21:24 <ehird`> taking a stack-based approach.
14:24:00 <ehird`> blah, i wish all i ever had to parse was s-expressions
14:32:10 <ehird`> i highly doubt an LC parser could fit into 20 lines of python anyway
14:33:57 <ehird`> identifiers being anything but a space, a tab, or a newline, lambdas being \ followed by many identifiers, followed by a period, followed by an expression, and application being implicit and left-associative, but with parens supported (e.g. (\n f x. f ((n f) x))(\f x. f (f x)))
14:34:00 <ehird`> honestly looks like more than 20 lines to me
14:35:37 <oklopol> we'll see after these two episodes i'm still gonna watch
14:41:01 -!- oerjan has quit ("leaving").
14:45:17 -!- DaFive has joined.
14:46:20 -!- RodgerTheGreat has joined.
14:50:17 <DaFive> is there anybody from russia?
14:52:10 -!- DaFive has left (?).
14:54:27 -!- kwertii has joined.
15:10:55 -!- kwertii has quit (No route to host).
15:11:34 <ehird`> in the lambda calculus, is it possible to create a function (G f) such that (N1 (G f) N2) is (f N1 N2), assuming N1 and N2 are church numerals?
15:12:34 <oklopol> how do you represent church numerals?
15:14:26 <ehird`> Church numeral N is \f x. (f^N)x
15:14:32 <ehird`> so 3 is \f x. f (f (f x))
15:14:46 <ehird`> and 5 is \f x. f (f (f (f (f x))))
15:15:20 <ehird`> \fx.fffx is \f x. ((f f) f) x
15:15:37 <ehird`> left-associative and all that
15:15:50 <oklopol> <ehird`> i'm parsing \x.\y.\z.xyz as x(yz) not (xy)z, right now
15:16:02 <ehird`> i was describing a bug
15:16:19 <ehird`> besides, i'm suspending my parsing efforts until I see yours because my efforts are going overblown and insane
15:16:34 <oklopol> then i better do it someday xD
15:18:26 <ehird`> grammar: an identifier is any string but cannot contain a space, tab, newline, (, ), or \.
15:18:53 <ehird`> an expression can be \(1 or more identifiers). expr, \x y.z is \x.\y.z
15:19:04 <oklopol> so \fx.fffx has other problems too.,
15:19:06 <ehird`> \ x y.z is equal to \x y. z (whitespace doesn't really matter)
15:19:21 <oklopol> ws is for tokenizing, that is.
15:19:21 <ehird`> a b c d is ((a b) c) d (left-associative)
15:19:31 <ehird`> it should be \f x. f f f x
15:20:11 <ehird`> or any sort of combination like that
15:21:36 <ehird`> also (expr) is an expr.
15:21:47 <ehird`> whitespace, as you can see, is ignored apart from to seperate tokens
15:38:10 <oklopol> ehird`: am i allowed to use regexes? :)
15:38:36 <oklopol> i'm having a hard time keeping this under 20 when a single identifier match is like 6 lines...
15:41:45 <ehird`> hehe, i'll give you... hmm... 50 :P
15:48:04 <oklopol> i think i have it, 21 lines, no densing sone yet
15:48:23 <ehird`> (\n f x. f (n f x)) \f x. f (f (f x))
15:48:45 <ehird`> (\ n f x.(f((n f)x))\f x.f (f(f x))
15:49:02 <ehird`> \x y. x y z is (\x y. x y z), not (\x y. x y)z
15:49:13 <ehird`> (i.e. lambda abstractions stretch as far right as possible)
15:49:29 <ehird`> a b c d e is equivilent to (((a b) c) d) e
15:49:49 <ehird`> if 21 lines parses all that
15:51:03 <ehird`> \x.x\y.y is (\x. x (\y. y))
15:51:24 <ehird`> (because of the lambda-stretches-right rule)
15:53:45 <ehird`> (\x y z. E) is equal to (\x. \y. \z. E)
15:55:00 <oklokok> kay, other keyboard stopped working fully
15:55:23 <oklokok> i love it how pyidle will just crash completely is i do an infinite loop
16:06:10 <oklokok> i'll restart, i realized at some poing i was actually doing a b c = a (b c)...
16:06:36 <oklokok> my memory is pretty selective.
16:06:56 <ehird`> it's not easy to parse left-associative grammars..
16:11:09 <ehird`> especially considering, if you're parsing recursive-descent style, it's impossible
16:11:21 <ehird`> well you could still try i guess, making a mashup of styles :)
16:13:00 <oklokok> every time i close the source and reopen it, i have to remake all tabs
16:19:53 <oklokok> ehird`: this parses right everything except expressions with lambda creation
16:20:06 <oklokok> function assignation works perfectly
16:20:21 <oklokok> lambdas work if they aren't used
16:20:25 <ehird`> example where it fails + works
16:20:33 <oklokok> (\ n f x.(f((n f)x))\f x.f (f(f x))
16:21:17 <oklokok> okay, i'm not sure it works...
16:21:22 <ehird`> plus what is (\ n f x.(f((n f)x))\f x.f (f(f x)) parsed equivalent to?
16:21:42 <oklokok> (\ n f x.(f((n f)x))\f x.f (f(f x))
16:21:45 <oklokok> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this one
16:21:47 <ehird`> so what is (\ n f x.(f((n f)x))\f x.f (f(f x)) parsed as?
16:21:59 <ehird`> i.e. what is an expression that parses to the same thing?
16:22:04 <oklokok> just the first lambda, the assignation works
16:22:19 <ehird`> what about ((\ n f x.(f((n f)x))(\f x.f (f(f x))))
16:22:38 <oklokok> anyway my point is that i have to leave soon
16:22:51 <ehird`> the problem might be, by the way, that you aren't recognizing an expression after an expression
16:22:58 <oklokok> i'll finish this, but can't promise it'll happen now
16:23:04 <ehird`> i.e. after parsing an expression, you're not looking ahead for another
16:23:19 <oklokok> it's not a bug, it's that i'm trying to be terse :)
16:23:43 <ehird`> forget about being terse then :P
16:24:10 <ehird`> if you manage to parse it in any sort of 1/4th of kind-of-sanity, i'm impressed
16:24:15 <oklokok> "g s (e b f (y h rt) d x) (s w) fwe"
16:24:16 <oklokok> [[[['g', 's'], [[[[['e', 'b'], 'f'], [['y', 'h'], 'rt']], 'd'], 'x']], ['s', 'w']], 'fwe']
16:24:34 <oklokok> this is trivial to archieve in ~10 lines
16:24:36 <ehird`> you really want :apply and :lambda prefixes
16:24:43 <oklokok> it's the lambdas that are a problem
16:24:44 <ehird`> "x y" -> ["apply", "x", "y"]
16:24:56 <ehird`> "x y z" -> ["apply", ["apply", "x", "y"], "z"]
16:25:10 <ehird`> it's simpler than just arrays
16:25:31 <ehird`> "\x y. x y" -> ["lambda", "x", ["lambda", "y", ["apply", "x", "y"]]]
16:25:35 <oklokok> i'll just have '^' be a special macro for lambdas
16:25:50 <oklokok> i'm not gonna do that, i want a readable output
16:26:18 <oklokok> if you know any lisp, you'll find mine good.
16:26:39 <ehird`> but lisp is not the lambda-calculus
16:26:59 <oklokok> anyway, what's wrong with a lisp-like way to do that?
16:27:17 <oklokok> why use "apply" and lose the ability to actually look at it?
16:27:48 <oklokok> i can add the string there in 5 seconds, but it'll only make it ugly, i'm not gonna
16:27:52 <ehird`> because parse trees are not for looking at, they're for the easiest machine mangling
16:28:06 <ehird`> my form is easy for a machine to parse and allows "^" as an identifier
16:28:09 <oklokok> stop complaining about details, choosing a representation isn't programming :)
16:28:39 <oklokok> that is as easy to machine-mangle as having "lambda" ther
16:28:45 <oklokok> except mine is faster, of course
16:30:04 <oklokok> it isn't, but it's not slower either
16:30:09 <oklokok> and just as easy to actually run
16:31:32 <ehird`> but restricts identifiers
16:31:37 <ehird`> my spec didn't disallow ^
16:32:52 <oklokok> that can be made into a typecheck
16:33:00 <oklokok> and it won't be disallowed
16:33:21 <ehird`> this is growing complex :)
16:33:31 <oklokok> really, that's not something you care about when implementing this, if there's any sense in the implementation, you can do it in 5 secs afterwards.
16:35:08 <oklokok> [['apply', [[[[['\\', 'n'], 'f'], 'x'], '.'], 'f'], [['n', 'f'], 'x']], ['lambda', ['f', 'x'], ['apply', 'f', ['apply', 'f', ['f', 'x']]]]]
16:35:08 <oklokok> [['apply', [[[[['\\', 'n'], 'f'], 'x'], '.'], 'f'], [['n', 'f'], 'x']], ['lambda', ['f', 'x'], ['apply', 'f', ['apply', 'f', ['f', 'x']]]]]
16:39:52 <ehird`> that's... really wrong :P
16:40:25 <ehird`> i guess i'll parse unlambda-style for now
16:44:53 -!- blahbot` has quit (Remote closed the connection).
16:46:09 -!- blahbot` has joined.
16:46:13 -!- blahbot` has quit (Remote closed the connection).
16:46:21 <ehird`> oklokok, !! example parsetree?
16:46:26 <oklokok> expr="(\\n f x.f(n f x)) \\f x. f (f (f x))"
16:46:26 <oklokok> ['apply', ['lambda', ['n', 'f', 'x'], ['apply', 'f', ['apply', ['apply', 'n', 'f'], 'x']]], ['lambda', ['f', 'x'], ['apply', 'f', ['apply', 'f', ['apply', 'f', 'x']]]]]
16:47:17 <oklokok> unless you want currying, which you most likely want :)
16:47:17 <ehird`> ['lambda', ['n', 'f', 'x' is not right
16:47:26 <ehird`> it should be ["lambda", "n", ["lambda", "f"...
16:47:34 <oklokok> unless you want currying, which you most likely want :)
16:47:44 <ehird`> well apart from currying, yep, it's completely correct
16:47:50 <ehird`> what about \x.x\y.y - how does that parse?
16:48:27 -!- blahbot` has joined.
16:48:29 <oklokok> ['lambda', ['x'], ['apply', 'x', ['lambda', ['y'], 'y']]]
16:48:53 <oklokok> it's long, didn't have the time to smallify it
16:49:00 <oklokok> but it can be reduced into 30 or so
16:49:13 <ehird`> currying isn't too hard really
16:50:51 * ehird` wants to see the code =)
16:50:58 <oklokok> http://www.vjn.fi/pb/p424155361.txt
16:51:33 <oklokok> it's not pretty, most would say, but it's pretty good code for the most part
16:52:31 <oklokok> http://www.vjn.fi/pb/p144223341.txt
16:52:38 <oklokok> it just uses the Itr class
16:52:51 <ehird`> you don't need parse_ski there do you?
16:52:51 <oklokok> you can use StringIO as well, i've just extended it a bit
16:53:12 <oklokok> you need to the latter file, and make it otools.py
16:53:13 <ehird`> parse_ski. unless that has nothing to do with SKI calculus
16:53:23 <ehird`> in which case it's badly named =)
16:53:41 <oklokok> otools is used in parse_ski
16:54:14 <ehird`> but ... you're not parsing ski
16:54:39 -!- blahbot` has quit (Remote closed the connection).
16:55:56 -!- blahbot` has joined.
16:55:57 <blahbot`> [[:lambda, "f", ["x$fx", [:lambda, "", []]]]]
16:57:00 <ihope> You call that reduction?
16:57:33 <ehird`> %reduce is currently %parse ;P
16:58:04 <ihope> Why isn't ` apply? :-P
16:58:10 <ehird`> because ^f^x`fx looks ugly
16:58:19 <ihope> Why isn't \ lambda? :-P
16:58:30 <ihope> Why am I saying :-P so much? :-P
16:58:30 <ehird`> because \f\x$fx looks ugly
16:58:38 <ehird`> <ihope> Why am I saying :-P so much? :-P
16:58:38 <ehird`> <ehird`> because \f\x$fx looks ugly
16:58:42 <ihope> Does \f\x`fx look ugly?
16:58:50 <ehird`> oklokok, you're parsing lambda calculus
16:59:11 <oklokok> i don't care about naming that much.
16:59:24 <ihope> Well, I think I've figured out a nice way to allow syntax to be added to a language.
16:59:27 <oklokok> anyway, i didn't make that all that usable for people who don't know what it does
16:59:47 <ihope> Take GHC's implicit parameter extension and run away with it.
17:00:04 * ehird` 's solution: tokenize the whole program at load-time, but only parse as needed
17:00:06 <ihope> Or something like that, anyway.
17:00:10 <oklokok> ehird`: parse_ski parses lambda calculus, you rename it if you feel like it, i gotta go now
17:00:12 <ehird`> add some syntax to define syntax based on tokens, voila
17:00:39 <oklokok> ehird`: was my code of any help?
17:00:40 <ehird`> <example was here but is too big>
17:00:46 <ehird`> oklokok, yes thanks =)
17:00:50 <oklokok> i gotta leave, comment it somehow
17:00:51 <ihope> Use \ to denote a pattern, and have free variables just be part of the type.
17:01:19 <ihope> x :: (x :: a) => a
17:01:40 <ehird`> i think my APL-alike language counts as esoteric
17:01:51 <ehird`> fib<-{=0=>0->=1=>1->$(-1)+$(-2)}
17:02:03 <ihope> \x :: Pat a [x :: a]
17:02:33 <ihope> Or something close to those.
17:03:15 <ehird`> that parses as fib <- { ((= 0) => 0) -> ((((= 1) => 1) -> ($ (- 1) + $ (- 2)lots of closing parens
17:03:30 <ehird`> except you can define your own postfix, prefix and binary operators too.
17:03:51 <ehird`> and = 1, - 1, etc work because binary operators implicitly have _ on the left (_ is the argument - you can also name arguments)
17:04:05 <ihope> Make it {x : a} instead of (x :: a) and {x : a} instead of [x :: a].
17:04:32 <ehird`> x=>y is the pair like lispish (x . y)
17:04:49 <ehird`> "if x, then y, else z"
17:04:58 <ehird`> it delays the evaluation of x (i.e. the left of the pair passed to it)
17:05:05 <ehird`> and is right-associative so:
17:05:19 <ehird`> is "if x, then y, else if a, then b, else c."
17:05:36 <ehird`> $ is the current function (used for recursion)
17:06:07 <ehird`> so, fib<-{=0=>0->=1=>1->$(-1)+$(-2)} is "if argument is 0, then 0, else if argument is 1, then 1, else current function (argument minus one) plus current function (argument minus 2)"
17:06:16 -!- sebbu has joined.
17:06:29 <ehird`> (harder: evaluate THAT!)
17:07:08 -!- blahbot` has quit (Remote closed the connection).
17:07:44 -!- blahbot` has joined.
17:07:58 <ihope> (->) :: Pat a s -> (s => b) -> a -> b
17:08:32 <ehird`> that doesn't allow for definition of my own operator working like that
17:08:40 <ehird`> i.e. lazily forcing evaluation of a part of a pattern match
17:08:53 <ehird`> that kind of function/operator-interaction is insane
17:09:06 <ehird`> -> tells => not to evaluate its left when => knows nothing about ->
17:09:31 <ihope> This is sort of my own thing, here.
17:09:47 <ehird`> well don't blame me for seeing -> and => and jumping to conclusions :P
17:10:06 <ehird`> especially (s => b) -> a
17:10:16 <ihope> Also, I seem to be using -> for multiple things.
17:10:42 <ihope> And I'm capitalizing inconsistently.
17:10:58 <ihope> If (->) is defined appropriately, then "
17:11:30 <ihope> If (->) is defined appropriately, then "\x -> x + 3" becomes an expression rather than special syntax.
17:12:03 <ehird`> but not as clever as... THE ARBITARY PARSERORNATOR
17:12:05 <blahbot`> [[:lambda, 120, [[:apply, ["x", " ", "y"], []]]]]
17:12:07 <ihope> Case/of expressions can also be defined.
17:12:07 <blahbot`> [[:lambda, 120, [[:apply, ["x", "y"], []]]]]
17:12:15 <blahbot`> [[:lambda, "x", [[:apply, ["x", "y"], []]]]]
17:12:20 <ihope> THE ARBITRARY PARSERORNATOR?
17:12:51 <ehird`> the program is tokenized at the start, but it only parses as little as it can at a time
17:12:51 <ihope> Allow new syntax to be defined?
17:13:02 <ehird`> and you can modify the parser on the fly, using special syntax
17:13:09 <ehird`> (You can also change that special syntax it being part of the parser and all)
17:13:25 <ihope> Again, reminds me of a... language?
17:13:39 <ehird`> Combine that with a self-hosted interpreter/compiler, and you have a system that loops inside itself performing major internal surgery on itself
17:14:14 <ihope> I think I had a language once called [\]
17:15:07 <ihope> [ adds syntax, \ escapes, ] removes syntax.
17:15:24 <ihope> I think /// can be called a much better version of [\]
17:15:42 <ihope> I don't remember how syntax-adding worked...
17:15:47 <ehird`> i'm interested in a blend between C#, Groovy, Lisp, Python, Perl, and my syntax-generator
17:15:51 <ehird`> I think it could be very interesting.
17:16:03 <ehird`> (It looks, mentally, less horrific than it sounds)
17:16:07 <blahbot`> [[:lambda, "x", [[:apply, ["x", "y"], []]]]]
17:16:08 <lament> ehird`: sounds like perl.
17:16:17 <ehird`> lament, Perl is a blend between perl and something else?
17:17:05 <blahbot`> [:lambda, "x", [:apply, "x", "y"]]
17:17:14 <blahbot`> [:lambda, "f", [:lambda, "x", [:apply, "f", [:apply, "f", "x"]]]]
17:17:29 <blahbot`> [:apply, [:lambda, "x", [:apply, "x", "x"]], [:lambda, "x", [:apply, "x", "x"]]]
17:18:01 <ehird`> %reduce ^g$^x$g$xx^x$g$xx
17:18:01 <blahbot`> [:lambda, "g", [:apply, [:lambda, "x", [:apply, "g", [:apply, "x", "x"]]], [:lambda, "x", [:apply, "g", [:apply, "x", "x"]]]]]
17:18:38 <ehird`> %reduce $^n^f^x$f$$nfx^fx$f$f$fx
17:18:39 <blahbot`> [:apply, [:lambda, "n", [:lambda, "f", [:lambda, "x", [:apply, "f", [:apply, [:apply, "n", "f"], "x"]]]]], [:lambda, "f", "x"]]
17:18:55 <ehird`> maybe i should implement that blend someday
17:22:57 -!- oklokok has quit (Connection timed out).
17:28:56 -!- blahbot` has quit (Remote closed the connection).
17:29:13 -!- blahbot` has joined.
17:29:59 <ehird`> %reduce $^n^f^x$f$$nfx^f^x$fx
17:30:52 <ehird`> %reduce $^n^f^x$f$$nfx^f^x$fx
17:32:51 <ehird`> %reduce ^g$^x$g$xx^x$g$xx
17:32:57 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:34:09 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:34:24 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:34:41 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:34:42 <blahbot`> [:lambda, "g", [:apply, [:lambda, "x", [:apply, "f", [:apply, "x", "x"]]], [:lambda, "x", [:apply, "f", [:apply, "x", "x"]]]]]
17:35:09 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:36:12 * ehird` wonders why that isn't working
17:36:17 <ehird`> %reduce $^g$^x$g$xx^x$g$xx^g$^x$g$xx^x$g$xx
17:36:19 <blahbot`> 0. reduce $^g$^x$g$xx^x$g$xx^g$^x$g$xx^x$g$xx
17:38:43 -!- blahbot` has quit (Remote closed the connection).
17:41:57 -!- blahbot` has joined.
17:42:58 <ehird`> %reduce $^n^f^x$f$$nfxn
17:46:03 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:46:47 <ehird`> That should be $f$^x$f$xx^x$f$xx, shouldn't it?
17:52:41 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:53:05 <ehird`> that's just one reduction isn't it
17:54:30 <ehird`> that's just one reduction isn't it
17:54:32 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
18:18:32 <ihope> %reduce $^g$^x$g$xx^x$g$xxf
18:32:09 <ehird`> or should it be $f$^x$f$xx^x$f$xx
18:32:25 <ehird`> %reduce $^x$f$xx^x$f$xx
18:33:37 <ehird`> %reduce $^x$f$xx^x$f$xx
18:33:49 <ehird`> That's with call-by-value
18:33:53 <ehird`> but call by value breaks Y, right?
18:34:05 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
18:34:15 <ehird`> %reduce $^x$f$xx^x$f$xx
18:34:33 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
18:35:09 <ehird`> ... does that look right to you
18:37:23 <ehird`> %reduce $$^f^s^b$$bfs^x^yx^x^yy
18:37:50 <ehird`> %reduce $^p$p^x^yx$$^f^s^b$$bfs^x^yx^x^yy
18:38:07 <ehird`> %reduce $^p$p^x^yx$$^f^s^b$$bfs^x^yx^x^yy
18:38:14 <ehird`> %reduce $^b$$b^x^yx^x^yy^x^yx
18:38:19 <ehird`> %reduce $$^x^yx^x^yx^x^yy
18:38:36 <ehird`> %reduce $^p$p^x^yx$$^f^s^b$$bfs^x^yx^x^yy
18:38:40 <ehird`> %reduce $^b$$b^x^yx^x^yy^x^yx
18:38:46 <ehird`> %reduce $$^x^yx^x^yx^x^yy
18:38:51 <ehird`> %reduce $$^x^yx^x^yx^x^yy
18:39:11 <ehird`> %reduce $^g$^x$g$xx^x$g$xx^x^yx
18:39:17 <ehird`> %reduce $^x$^x^yx$xx^x$^x^yx$xx
18:39:17 <blahbot`> $^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:39:19 -!- lament has set topic: Esoteric language discussion | FORUM AND WIKI: esolangs.org.
18:39:22 <ehird`> %reduce $^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:39:25 <ehird`> %reduce $^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:39:25 <blahbot`> ^y^x$^x^y$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:39:35 <ehird`> i hope this is working :)
18:39:37 <ehird`> %reduce ^y^x$^x^y$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:39:37 <blahbot`> ^y^x$^x^y$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:39:41 <ehird`> ... looks like it isn't
18:39:42 -!- lament has set topic: Esoteric programming language discussion | FORUM AND WIKI: esolangs.org.
18:39:51 <ehird`> this is Y with callbyvalue spiralling out of control isn't it?
18:39:55 <ehird`> %reduce ^y^x$^x^y$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:39:55 <blahbot`> ^y^x$^x^y$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:40:07 <ehird`> %reduce ^y^x$^x^y$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:40:07 <blahbot`> ^y^x$^x^y$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:40:20 <ehird`> lament, what do you think?
18:40:31 <ehird`> %reduce $^g$^x$g$xx^x$g$xx^x^yx
18:40:35 <ehird`> %reduce $^x$^x^yx$xx^x$^x^yx$xx
18:40:35 <blahbot`> $^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:40:39 <ehird`> %reduce $^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:40:39 <blahbot`> ^y^x$^x^y$^x$^x^yx$xx^x$^x^yx$xx$$^x$^x^yx$xx^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:40:53 <ehird`> same happens with call-by-name. OK
18:41:20 -!- lament has set topic: Esoteric programming language discussion | FORUM AND WIKI: esolangs.org | CHANNEL LOGS: http://ircbrowse.com/cdates.html?channel=esoteric.
18:45:54 <ehird`> %reduce $^g$^x$g$xx^x$g$xx^x^yx
18:46:15 <ehird`> %reduce $^x$^x^yx$xx^x$^x^yx$xx
18:46:16 <blahbot`> $^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:46:25 <ehird`> %reduce $^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:46:25 <blahbot`> ^y^x$^x^y$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx$^x^y^x$^x^yx$xx$^x$^x^yx$xx^x$^x^yx$xx
18:46:29 <ihope> It shouldn't contain $^ at all, should it?
18:46:41 <ihope> Just how far is it supposed to be reducing?
18:46:51 <ehird`> ihope, To a normal form if there are no free variables
18:47:07 <ehird`> $^xxa reduces to the symbol a
18:47:11 <ehird`> or rather, the free variable a
18:47:24 <ehird`> $^x^y$xyab reduces to $ab
18:47:31 <ehird`> but $^g$^x$g$xx^x$g$xx^x^yx reduces to that big lambda.
18:47:51 <ihope> %reduce $^x$xx^x$xx
18:47:55 <ehird`> i'm just reducing until there's 1. a change between two reductions and 2. still free variables
18:48:06 <ehird`> but my algo is flawed apparently
18:48:11 <ihope> A change between two reductions?
18:48:36 <ehird`> while x has free variables and x != reduce(x), set x = reduce(x)
18:50:26 <ehird`> why would $ab reduce to a?
18:50:35 <ehird`> %reduce $^g$^x$g$xx^x$g$xx^x^yx
18:50:49 <ehird`> maybe my has_free? algorithm is wrong
18:51:53 <ehird`> has_free? expr, bound = if expr is a variable and isn't in bound, TRUE! otherwise if expr is a variable, FALSE! otherwise if expr is an application, has_free? function, bound or has_free? argument, bound. otherwise, if i'm a function, has_free? code, bound + my_argument_name
18:54:22 <ehird`> %reduce $^n^f^x$f$$nfxa
18:54:28 <ehird`> %reduce $^n^f^x$f$$nfx$ab
18:54:32 <ehird`> %reduce $^n^f^x$f$$nfx$a$bc
19:27:39 -!- andreou has joined.
19:43:32 -!- oerjan has joined.
19:56:31 <ihope> Reduce until it changes?
20:00:37 -!- Sgeo has joined.
20:00:53 <ehird`> reduce until it doesn't change
20:01:39 <ihope> What are your rules for reduction?
20:01:40 -!- blahbot` has quit (Remote closed the connection).
20:01:54 <ehird`> ihope, alpha-conversion and beta-reduction
20:02:03 <ehird`> actually, not even alpha-conversion
20:02:23 <ehird`> i don't rename variables, i just replace each occurence of them with the argument's value, assap
20:02:30 <ehird`> I reduce on alpha-conversion
20:03:07 <ihope> So if you have a lambda applied to something, it reduces; otherwise, nothing?
20:03:07 <ehird`> and beta-reduction is just the identity function for variables and lambdas, and A(B(function), B(function argument name), argument)
20:03:36 <ihope> Does the lambda-applied-to-something have to be at the "top" of the expression, or can it be anywhere within?
20:03:45 -!- blahbot` has joined.
20:05:25 <ehird`> ok so maybe i need alphaconversion
20:05:38 <ehird`> why isn't that reducing further.
20:07:12 <ehird`> (\x.(\x.x)x)y should be y, right? :/
20:08:53 -!- blahbot` has quit (Remote closed the connection).
20:09:35 -!- blahbot` has joined.
20:09:49 -!- blahbot` has quit (Remote closed the connection).
20:10:03 <ihope> What language is this in?
20:10:33 <ehird`> the language being reduced in the lambda-calculus, but with ^xE instead of \x.E and $xy instead of (xy)
20:10:38 -!- blahbot` has joined.
20:10:42 <pikhq> Rubys are bad for you, mmkay?
20:11:01 -!- blahbot` has quit (Client Quit).
20:11:17 <pikhq> puts "Says this little Tcl/Ruby polyglot (I think)."
20:11:21 -!- blahbot` has joined.
20:12:29 -!- sekhmet has quit ("Reconnecting").
20:12:34 -!- sekhmet has joined.
20:12:39 <ehird`> okay apparently [:apply, "y", "x"] is a black hole.
20:13:01 -!- blahbot` has quit (Remote closed the connection).
20:13:20 <pikhq> [apply {y {return $x}}] There. Happy?
20:13:37 -!- blahbot` has joined.
20:15:14 <andreou> make it say "oh andreou is so sexy"
20:15:26 <ihope> oh andreou is so sexy
20:17:41 <ehird`> (\x.(\x.something x)something)abc shouldn't be (\x.something abc)something
20:17:47 <ehird`> it should be (\x.something x)something
20:18:08 <ihope> Replacing with the wrong thing?
20:18:20 <ihope> Replacing too early?
20:18:26 <ehird`> replacing inner lambda's arguments with the same argument name as an outer lambda's arguments values
20:18:48 <ihope> Replacing the inner lambda's variable with what was passed to the outer lambda.
20:19:45 <ihope> Make it not do that.
20:19:48 <ehird`> when they have the same name.
20:19:55 <ihope> Yes, when they have the same name.
20:20:11 <ehird`> i will, but time to figure out the best way to do that first :)
20:20:31 <ehird`> ^ why doesn't that reduce to ^xx!?!!
20:21:14 <ihope> Why did it stop reducing?
20:21:32 <ehird`> that's what i'm trying to work out
20:21:52 <ihope> When does it stop reducing, and when's it supposed to?
20:22:46 <ehird`> it stops reducing /then/ and it's supposed to stop reducing when X = reduce(X)
20:22:50 <ehird`> i.e. as far as possible
20:24:26 <ehird`> however as we can see, reduce($^yy^xx) = ^xx
20:25:44 <ehird`> http://pastie.caboo.se/80390 the full code from start to finish it probably has loads of bugs.
20:28:45 <ehird`> that SHOULD all be done in one step.
20:28:57 <ehird`> the last two steps should be combined
20:52:35 -!- Sgeo has quit (Remote closed the connection).
21:21:47 -!- kwertii has joined.
21:21:56 -!- kwertii has quit (Remote closed the connection).
21:27:28 -!- Sgeo has joined.
21:52:48 <lament> harry potter kills voldemort with brainfuck!
21:53:26 <SimonRC> "Harry, I am your mother."
21:55:43 <pikhq> "Harry, I am your ,[.,]"
21:55:52 <ehird`> the internet will be a minezone for the next few weeks
21:56:00 <ehird`> of the type "<spoiler> <rage> <laughter> <repeat>"
21:56:20 <pikhq> I might want to do a self-imposed media blackout until I get the book. . .
21:56:39 <pikhq> I at least *think* I'll be getting one at release.
21:57:03 <pikhq> If so, I ought to be done in time to avoid the spoilers. :)
21:57:33 <ehird`> that's what loads of people are doing
21:57:34 -!- Figs has joined.
21:57:40 <ehird`> so the internet will be a minefield with only a few mines
21:57:45 <SimonRC> I have already seen the aftermath of some by-that-time-removed fake spoilers.
21:58:41 <Sukoshi> So ... slow to develop in ....
21:58:46 <SimonRC> Harry kills V, goes insane, and travels back in time to become V.
21:58:54 -!- Tritonio has quit (Remote closed the connection).
21:59:07 <Figs> I'm pretty sure I know what the ending is, though not the particulars
21:59:08 <SimonRC> Sukoshi: depends on the language
21:59:28 <ehird`> Figs, if you say a word - many geeks and nerds will want your head on a stick. that is all
21:59:29 <SimonRC> Sukoshi: Haskell is more fascists about types than java
21:59:31 <Sukoshi> Must ... inspect data structures in real time ...
21:59:36 <Figs> no, not like that :P
21:59:37 <ehird`> (also, tempted to pre-emptively /ignore figs :))
21:59:48 <Sukoshi> SimonRC: Haskell is just st00pd though :P
21:59:53 <ehird`> SimonRC, Voldemort kills Harry, goes insane, and travels back in time to become Harry
22:00:04 <ehird`> ^ THAT'S WHY IT DIDN'T KILL HIM!
22:00:20 * ehird` will obviously turn out to be completely right
22:00:28 <Sukoshi> Or Voldermort is just the result of Bowser raping Ron's dad.
22:00:35 <SimonRC> Harry wakes up to find he is 28 years old and in a loony bin
22:00:36 <Sukoshi> Who then travels back in time to become Voldermort.
22:00:54 <Sukoshi> Hey... Bowser's spikers will do that to anyone!
22:01:00 <Figs> it's obvious what will happen. it's been set up from book one :P
22:01:32 <Figs> as long as he lives
22:01:49 <SimonRC> I have seen Harry surviving and dying both being pronounced "obvious"
22:01:59 -!- Tritonio has joined.
22:02:04 <ehird`> SimonRC, harry is in a superposition of both alive and dead
22:02:06 <pikhq> Someone please tell me when ehird's done with the spoilers.
22:02:10 <ehird`> you won't know which until you read the book
22:02:20 <ehird`> somebody tell pikhq that i didn't mean me
22:02:44 <ehird`> SimonRC, quantum pottermechanics
22:02:48 <pikhq> Fuck it. Someone PM me when the channel's done. :p
22:02:55 <Figs> I know another book that I think parallels it
22:02:58 <SimonRC> you have half-a-dozen different versions of the book printed with subtly different endings, but don't tell anyone!
22:03:13 <SimonRC> then the collectors will have to buy one copy of each version...
22:03:38 <SimonRC> then, you make one of the variations even rarer, generating insane frenzy
22:03:41 <lament> anybody here speak hebrew?
22:03:44 <pikhq> If I were Rowling, I'd have written up a fake book just to leak it intentionally. . .
22:03:56 <ehird`> pikhq, maybe that's why it took so long
22:04:12 <Figs> actually I had the whole "hollows" thing spoiled for me by the illustrator
22:04:15 <SimonRC> Every character not killed off will suffer through a large amount of really bad fanfic
22:04:20 <SimonRC> is that a good or bad thing?
22:04:45 <Sukoshi> pikhq: You *read* Harry Potter?
22:04:55 <lament> Figs: i don't see how the illustration spoils it in any way...
22:05:08 <ehird`> Sukoshi, May I gently remind you that this is a channel of nerds.
22:05:09 <Figs> not illustrations
22:05:18 <lament> Figs: you've talked to the illustrator?
22:05:18 <Figs> one who illustrates
22:05:23 <SimonRC> like most of these hyped things, it is not too bad, but is insanel overhyped
22:05:23 <Figs> but I can read online :P
22:05:47 <ehird`> Sukoshi, How is that the point?
22:06:02 <SimonRC> fortunately, LOLCODE has calmed down a bit
22:06:02 <pikhq> Sukoshi: It's a decent book series, which happens to have insane hype and some horrid merchandising deals.
22:06:08 <Sukoshi> After reading real Fantasy by people like Jordan, Modesitt, Friedman, Hobb, and Kerr, I can't even go back.
22:06:25 <ehird`> SimonRC, thank god indeed
22:06:36 <ehird`> SimonRC, LOLCODE is another case of the microsofts
22:06:38 <Figs> oh not the illustrator
22:06:45 <Figs> actually, a reviewer from Baltimore SUn
22:06:46 <Sukoshi> Harry Potter is, at best, a child's tale.
22:06:50 * pikhq wants to kill some people at WB for such monstrosities as HP underwear. . .
22:06:50 <ehird`> stealing an idea done before many times to not much success, making it worse, getting loads of hype
22:06:52 <Figs> *Baltimore SUn
22:06:54 <ehird`> of course MS is not the first to do that ;)
22:06:58 <Figs> *Baltimore Sun
22:07:06 <bsmntbombdood> Sukoshi: it's an easy to read and entertaining. so?
22:07:07 <pikhq> Sukoshi: I started on the series when I was about 9, so I've got an excuse. ;)
22:07:32 <lament> Sukoshi: if i read "real fantasy", i'd be some kind of a dork.
22:07:52 <SimonRC> HP is a frikkin' boarding-school story that turns into a destiny story
22:08:15 <pikhq> SimonRC: It doesn't *claim* to be more than that, really.
22:08:20 <bsmntbombdood> Sukoshi just doesn't like it because she thinks it won't enlighten her
22:08:22 <Figs> Hey, what's wrong with "real fantasy"? :P
22:08:49 * pikhq only reads for fun. . . Enlightenment is fun. Entertainment is fun.
22:08:57 * SimonRC starts to analogise HP to Star Wars, but realises this must have bben done already.
22:08:59 <pikhq> I'm easily pleased with reading material in hand. :)
22:09:09 <Figs> you know they released like 1000 copies of the book early by mistake, right?
22:09:17 <Figs> there's going to be a lawsuit over it :P
22:09:46 <oerjan> SimonRC: Irregular Webcomic has already done several fake spoilers, one of them SW
22:10:12 <pikhq> Snape kills Trinity with Rosebud!
22:10:20 <pikhq> bsmntbombdood: Yeah. . .
22:10:24 <SimonRC> IW is the only webcomic where I learn something new most days
22:10:25 <pikhq> So. . . Tempting. . .
22:10:35 <Figs> I haven't seen the leak, no
22:10:40 <Figs> heard of it yes
22:10:53 <Figs> no way in fucking hell am I touching that download :P
22:11:12 <Figs> fair chance of lawsuits
22:11:21 * ehird` has the positive aspect of not being able to read books from a computer screen
22:11:27 <ehird`> so the leak does not tempt me.
22:11:37 <Figs> yeah, that irritates me too :P
22:11:58 <lament> i'm not gonna read it until i find a spanish version
22:12:06 <lament> which will take months at least
22:12:08 <Figs> why risk my money, sanity and freedom over a shitty poorly readable copy when I can wait two or three more days and buy the real deal?
22:12:20 <lament> Figs: you're _paying_ for it?
22:12:36 <pikhq> ehird`: Why's that?
22:12:46 <Figs> I know. Rare for my to buy things.
22:12:56 <Figs> But yes, I'd rather not have it all spoiled.
22:13:02 <ehird`> lament, some people pay for things!
22:13:10 <Figs> while I wait 6 months for the library to have a copy :)
22:13:30 <ehird`> On a completely different note: http://qntm.org/f16 I love using a time machine which is bought and took back in time in later steps
22:13:59 <Figs> how the fuck do you have a difference of more than 150 pages in two copies of the same book?
22:14:38 <SimonRC> In Orwellian Britain, television watch YOU!
22:14:52 <ehird`> i also like the completely irrelevant steps.
22:14:54 <ehird`> like "Take your scotch tape and your box of cereal backwards in time by roughly 14,000,000,000 years and allow the preposterous quantity of scotch tape to undergo gravitational collapse to form a star. This star should be of sufficient mass to go supernova, generating large amounts of iron and other heavy elements. If you picked your spot correctly, this should result in the creation of our Sun and the planet Earth, both of which you ar
22:14:54 <ehird`> e therefore directly responsible for."
22:15:10 <Figs> you can read the Baltimore Sun's article on HP7 if you want minor spoilers
22:15:20 <SimonRC> ehird`: The best circular causality I have seen is in Flatterland.
22:15:36 <ehird`> SimonRC, this one's better considering it has nothing to do with "Making an F-16 from a cereal box, some Scotch tape, and a penny"
22:16:54 <ehird`> http://qntm.org/icecubes
22:20:15 <lament> they're tasty when they're made of sugar!
22:20:37 <ehird`> INTERESTING PROJECT: Basic analog computer by way of rube goldberg machine
22:21:04 <ehird`> Preferably using mainly household objects.
22:22:09 <Figs> ehird`, you've seen the lego babbage machines, right?
22:22:46 <Figs> http://acarol.woz.org/FullEngineFrontLarge.jpg
22:23:17 <Figs> http://www.mocpages.com/moc.php/13731
22:23:41 <Figs> and another article
22:23:42 <Figs> http://acarol.woz.org/
22:23:54 <ehird`> but, does it actually work
22:23:59 <Sukoshi> pikhq: I started Harry Potter when I was 9 too.
22:24:01 <ehird`> can you compute with it.
22:24:03 <Figs> works for 3 digits, I think
22:24:12 <Sukoshi> But this thing happened called ``Growing up'' that was pretty weird.
22:24:33 <Sukoshi> And then lots of stories became boring an unbelievable :|
22:25:07 <lament> then you can't be older than 20.
22:25:34 <Figs> ehird`, from the article, " My first generation Difference Engine could calculate 2nd order differences to 3 digits. Issues with the performance of the 'carry' operation prevented easy expansion to more orders of difference or the addition of more digits. It also had a single "modified" LEGO part in each adder unit which fell short of my goal to use only standard parts.
22:25:34 <Figs> The second generation machine, documented here, calculates to the same precision, but is capable of being expanded to 3rd order differences and 4 digits accuracy. Other than the paper printed digit labels used to output the answer, standard LEGO pieces are used without modification. "
22:25:36 <pikhq> ehird`: That guy is now my god.
22:25:43 * ehird` considers doign that analog-rube-goldberg thing anyway
22:26:15 <ehird`> i mean, that lego thing is cool and all but you don't see it roll a tennis ball down onto some rubber to hit a switch
22:26:26 <Figs> I think they did a better one with K'NEx
22:27:10 <Figs> actually, no this is an adder/subtractor
22:27:15 <ehird`> a k'nex calculator would be cool
22:27:17 <Figs> works up to 15
22:27:35 <ehird`> BUT what about meccano
22:27:37 <Figs> it's by some students at Olin
22:27:41 <Figs> http://gizmodo.com/gadgets/k.nex/room-sized-knex-calculator-274562.php
22:27:54 <ehird`> "In 1935 Meccano was the primary construction material used by J. B. Bratt in building several analog computers. The computers were used for several decades to calculate differential equations, and one such machine, the "Meccano Differential Analyser No. 2" survives to this day. That specific machine was used by the Allies in Operation Chastise where the computer played a critical role in planning the bombing runs for bombs that would b
22:27:54 <ehird`> ounce across water before colliding with and destroying German dams.[3] [4]"
22:28:03 <ehird`> and "In 2002 and 2005 (respectively), Tim Robinson constructed working Meccano models of Charles Babbage's Difference Engines #1 and #2."
22:28:11 <ehird`> http://www.meccano.us/difference_engines/rde_1/index.html
22:29:15 <Figs> the Olin one works more like boolean logic
22:29:15 <ehird`> the day when i get a rube goldberg machine to flick a peice of tape saying "1" to "2" will be the happiest day of my life. kind of. :P
22:29:27 <lament> difference engines are pretty boring, though.
22:29:57 <Figs> in physics, we had to build rube goldberg machines to move 500 grams exactly ___ cm
22:29:58 <ehird`> lament, analytical engines, then
22:29:59 <Figs> I don't remember how far
22:30:03 <ehird`> turing complete lego sets
22:30:11 <lament> analytical engines are a bit harder to construct, naturally
22:30:26 <Figs> I used a lego rebot as the last stage so we could just activate it and have it move correctly :)
22:30:39 <Figs> wow, I can't type today, can I? :P
22:31:06 -!- jix has quit ("CommandQ").
22:32:01 <Figs> http://www.physorg.com/news103997338.html
22:32:51 -!- liber has joined.
22:33:20 <pikhq> ehird`: The Lego robot kit is Turing complete, last I checked. . .
22:33:38 <ehird`> pikhq, but that has a computer chip and everything doesn't it?
22:33:42 <Figs> yeah, but interactive C sucks
22:34:01 <liber> Anyone know how BF works? When a loop quits does the memory pointer go back to where it was before the loop? my interpreter goes BAZAAR when it comes to multiple loops
22:34:17 <ehird`> when the loop ends it goes to z.
22:34:26 <ehird`> and the tape pointer doesn't change.
22:34:28 <Sukoshi> liber: You're thinking too hard.
22:34:34 <liber> when the loop ends it stays where it was when the loop ended
22:34:47 <Sukoshi> Just follow the instructions to the letter.
22:35:00 <Sukoshi> There are no high-level loop security, stack pointer, segment register-ness here.
22:35:04 <liber> Well. I'm not very good at programming. My bf interpreter behaves nuts. I have no idea why
22:35:10 <liber> It works for a while
22:35:15 <liber> and for simpler examples
22:35:46 <pikhq> Given the source, we may be able to help.
22:36:01 <liber> its commented in swedish though ...
22:36:12 <lament> liber: given brainfuck source code, can you find a quote's matching quote?
22:36:18 <ehird`> code is better than comments.
22:36:31 <pikhq> Where's a Swede when you need one? :p
22:36:32 <ehird`> good code is mostly self-explanatory. it's only concepts you should explain
22:36:47 <liber> well. I cant guarantee that its very good
22:36:57 <ehird`> my code generally has only a sprinkling of one-line comments above bits of code, and short descriptions of concepts and algorithms
22:36:57 <pikhq> What language did you write it in?
22:37:03 <ehird`> mainly my code explains itself
22:37:26 * ehird` is antiRubyButItISPracticalAndUseful
22:38:57 -!- DeviALT has joined.
22:39:07 <Figs> I emailed the guy from IOCC
22:39:31 <DeviALT> god, i always remarked that IRC was like multiplayer DOS, this really IS.
22:39:32 <liber> Before you start bashing my code: I am a musician, not anywhere near a programmer
22:39:37 <liber> http://pastebin.se/24992
22:39:41 <Figs> no I did get a reply
22:39:53 <lament> the best language for writing a brainfuck implementation is of course HQ9+B
22:40:00 <Figs> The answer is no :(
22:40:10 <lament> liber: Yes. Typical musician code :P
22:40:18 <liber> and for some reason I used instance-vars instead of anything else :)
22:40:26 <liber> I have no idea why
22:40:28 <ehird`> #Workaround for the STUPID STDIN.getc.
22:40:41 <Figs> and he said he didn't know of any Obfuscated C++ contests either :P
22:41:04 <ehird`> actually this code is just insane. :P
22:41:15 <Figs> I really should :P
22:41:20 <liber> ehird`: because if you have two , after eachother the getc first gets the first value, then the newline when you press enter
22:42:03 <liber> so the newline is supposed to be "loaded"?
22:42:08 <DeviALT> IRP is scary and frightening.
22:42:32 <Figs> I just got an awful idea
22:42:45 <lament> international obfuscated IRP contest!
22:42:48 <andreou> which reminds me of a heraclitean fragment
22:43:17 <lament> i don't think anybody tried obfuscated IRP yet
22:43:22 <DeviALT> 'oh god help this man is there an irp interpreter in the house?'
22:43:43 <liber> ehird`: there are some "debugging things" still in that code... example the "puts 'wtf!'"... just ignore that
22:44:25 <liber> the problem comes when there are loops... otherwise it works fine
22:44:36 <ehird`> please say "<rot13 of hello world>" rot13d and sha512-decoded while defining X to be...
22:44:38 <lament> well, what instrument do you play?
22:44:56 <oerjan> Please worble glak moofle "Hello, world!"
22:45:11 <Figs> I play flute. Are we forming a band?
22:45:29 <oerjan> Fnarlke thanks, skriffle.
22:45:39 <liber> we will write our notes in brainfuck
22:45:45 <pikhq> I sing. We're forming the ">,[>,]<[.<]"
22:46:04 <lament> do we -really- want to hear pikhq sing?
22:46:14 <pikhq> Depends. Do you like bass?
22:46:48 <liber> If anyone wants to hear an _insane_ bass: dl "J.D Sumner - Walk that lonesome road"
22:46:57 <liber> That's just creapy
22:47:08 <lament> at any rate i'll play the berimbau, didgeridoo, pandeiro and agogo
22:47:17 <liber> He goes down, without any problems to really low Ab
22:47:20 <RodgerTheGreat> what'll intellectuals do once somebody succeeds in solving chess?
22:47:20 <ehird`> Please ...---.--.-.-.-----
22:47:24 <Figs> Rodger, I misread that as "Hey Cool, Chickens have been solved."
22:47:25 <lament> and i suppose the cuica as well
22:47:57 <Figs> what do you mean by 'solved' checkers, anyway? :P
22:48:12 <DeviALT> the ai created to play cannot be beaten.
22:48:16 <lament> RodgerTheGreat: do any intellectuals still play chess? I thought they all switched to Go.
22:48:28 <pikhq> lament: Yeah, quite a few do.
22:48:55 <pikhq> liber: How does your program handle ">,[>,]<[.<]"?
22:49:07 * pikhq would try it, but I don't have a Ruby interpreter
22:49:25 <RodgerTheGreat> it bothers me a bit when people say things like "It's impossible to make an AI to play go at a human level". HUMANS are AIs that can play at a human level. The strategy just involves deeper analysis than a game like chess
22:49:56 <lament> RodgerTheGreat: humans are not AI.
22:50:08 <DeviALT> All is proceeding according to plan. Beep.
22:50:10 <Figs> depends if you believe in creationism, lament :P
22:50:31 <RodgerTheGreat> humans generate algorithms to play games on the fly, as they play
22:50:31 <liber> pikhq: are newlines supposed to be "read" in?
22:50:43 <liber> alright. Have to modify it a bit
22:50:58 <RodgerTheGreat> applying anything resembling logic to a game is essentially writing a very fast and loose program
22:50:58 <lament> RodgerTheGreat: humans are not AI. Don't confuse issues. The terminology is pretty straightforward.
22:51:40 <liber> pikhq: it loops... and loops
22:51:58 <lament> RodgerTheGreat: you could argue that they're _similar_ to AI but it's nonsense to say that they are.
22:52:02 <liber> there is something REALLY fishy with the loop method
22:52:07 <pikhq> It should take input, and reverse that when you get an EOF.
22:53:33 <Figs> lament, unless you believe in Creationism :P
22:53:43 <Figs> or weirder perversions of it, anyway
22:54:03 <Figs> ("Bwhahaha, we were crafted by the GAME MASTER!")
22:54:24 <Figs> typically, you shouldn't call us AI
22:54:29 <liber> pikhq: how do I input EOF?
22:54:58 <RodgerTheGreat> Figs: I'm not implying anything resembling creationism, I'm saying that our solutions to problems are of the same class as an AI we could write in a programming language
22:55:13 <oerjan> liber: i don't think your interpreter skips the loop entirely if the cell is 0 at the start
22:55:23 <lament> Figs: no, it doesn't matter if you believe in creationism or not, again you're confusing issues
22:55:29 <Figs> Naturally Intelligent Native Nincompoop Yanks!
22:55:37 <lament> RodgerTheGreat: that has never been proven by anybody and is probably not ture.
22:55:39 <RodgerTheGreat> we create algorithms to solve problems we encounter, and in so doing do something analagous to writing and executing a program
22:55:42 <andreou> creationism is much funnier that evolution
22:55:58 <Figs> lmanet: I was joking :)
22:56:02 <lament> RodgerTheGreat: do you have any evidence for that other than your own intuition? It goes against my intuition.
22:56:02 <liber> oerjan: how do you mean
22:56:03 <Figs> *Lament: I was joking
22:56:16 <Figs> but you killed my joke :(
22:56:24 <lament> Figs: it's only a joke when it's funny.
22:56:27 * Figs charges lament for the coffin
22:56:53 <Figs> it can still be a joke even if it isn't funny
22:56:59 <ehird`> liber, you handle EOF as nil
22:57:01 <Figs> it's just a "bad" joke then :)
22:57:07 <ehird`> make it set cell to 0 on eof
22:57:09 <Figs> or a "shitty" joke :)
22:57:17 <RodgerTheGreat> it's a logically consistent model. If you have a problem with models that are logically consistent but are by definition unprovable (by your criteria), go bitch at theoretical physicists.
22:57:17 -!- andreou has quit ("Leaving.").
22:57:29 <liber> ehird`: I don't really understand how you mean
22:57:30 <Figs> don't forget there's antihumor
22:57:42 <ehird`> liber, maybe you shouldn't be writing a bf interp, then :p
22:57:45 <Figs> Which is funny because it's not funny.
22:58:19 <ehird`> if you're writing a bf programmer you should generally get all of those concepts
22:58:36 <liber> Why not learn them as you go?
22:58:57 <lament> RodgerTheGreat: that aliens are spying on you when you go to the washroom is also a logically consistent model.
22:59:00 <ehird`> well.. because each affects the other
22:59:26 <lament> RodgerTheGreat: not sure what either scenario has to do with theoretical physics
22:59:53 <RodgerTheGreat> alright, go ahead and explain to me why you think a brain is super-turing.
23:02:07 <lament> i don't think the brain is super-turing. I think turing-completeness is pretty irrelevant in this case.
23:02:33 <lament> After all, all you need to play Go perfectly is a finite state machine.
23:03:55 <lament> there's nothing superturing about weather either, yet even the strongest computers can't predict it.
23:04:47 <liber> ehird`: btw: it is hard to insert an EOF when that kills the ruby-interpreter...
23:04:51 <Figs> There will be weather tomorrow somewhere.
23:04:56 <ehird`> liber, no it does not.
23:05:00 <Figs> Bwahaha. I just predicted the weather :D
23:05:01 <RodgerTheGreat> the problem with weather is possessing perfect information about the system's initial state. Go is a perfect-information game.
23:05:14 * Figs runs away to avoid being smacked
23:05:18 <liber> ehird`: yes it does
23:05:23 <liber> Although, I found the problem
23:05:36 <ehird`> liber, no it does not.
23:05:55 <ehird`> your program may make it that way
23:06:17 <liber> That was the python version :)
23:06:21 <Figs> famous last words :D
23:06:49 <ehird`> python doesn't do that either
23:06:54 <ehird`> but your prog might have
23:07:35 <Figs> these headphones suck.
23:08:38 <liber> anyways: the problem was that [ does not behave as it should. It does not leap to after ] if the ptr is 0
23:20:14 <Figs> [][][][][][][][][][][][][][][][][][][][][][][]
23:21:51 <pikhq> Well, after substitution, it does. . .
23:24:43 <Figs> haha C-- compiler
23:24:45 <oerjan> it may be wise to use his actual nick
23:25:30 <Figs> got mixed up between kok and pol, and got pok... I guess I could have gotten kol
23:25:52 <oerjan> _or_ you could get tab completion.
23:26:13 <Figs> it doesn't help if you're stupid :)
23:26:32 <Figs> I typed it first, then pressed tab complete :P
23:26:53 <Figs> and wrote pok :P
23:27:27 <Figs> could be worse, I could have called him Oktokop
23:28:22 <Figs> I'll keep in mind to try to reduce typoes
23:28:39 <lament> in big-O notation: OklOpOl
23:29:27 <oerjan> you mean O(kl)O(p)O(l)
23:29:29 -!- blahbot` has quit (Remote closed the connection).
23:29:35 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
23:30:34 -!- Figs has changed nick to [x|x.
23:30:49 -!- [x|x has changed nick to Figs.
23:31:25 <Figs> an attempt at making my nick a list comprehension
23:31:42 <Figs> nickserve doesn't like <- apparently
23:32:58 -!- lament has changed nick to bra|ket.
23:33:37 <oerjan> too bad my client doesn't use an initial <
23:38:54 <Figs> I got an idea for how I could make my parser work easily
23:39:01 <Figs> pass boost.any's around
23:39:09 <Figs> I'll have a tree of boost.any
23:39:48 <pikhq> I've got an idea for how to make a parser work. . .
23:40:03 <pikhq> Just use GNU Bison.
23:40:14 <Figs> no. I'm doing this inline in C++
23:42:25 <pikhq> Yes, Conway's Game of Life is perty.
23:42:57 <SimonRC> In Soviet Russia, VCR program YOU!!
23:42:59 <Figs> hehe, write a calculator in that :P
23:43:59 -!- Figs has quit (Read error: 104 (Connection reset by peer)).
23:44:09 -!- Figs has joined.
23:44:55 <SimonRC> In Soviet Russia, TV watch YOU!!
23:45:03 <oerjan> no, no, in Soviet Russia, VCR doesn't manage to program YOU
23:45:20 <SimonRC> but "program" sounds properly orwellian
23:45:35 <SimonRC> that is supposed to be the joke with the Soviet Russial jokes
23:46:09 <oerjan> In Soviet Russia, joke tell on YOU
23:47:07 <SimonRC> "In California you can always find a party, but in Soviet Russia the Party can always find YOU!"
23:48:12 * Figs tries very hard not to make bad jokes about missing colons :P
23:48:30 <oerjan> Figs: darn, you beat me to it
23:48:37 <oerjan> or maybe i tried too hard
23:48:57 <oerjan> In Soviet Russia, colon miss YOU
23:49:07 <Figs> don't _strain_ yourself :)
23:49:31 <SimonRC> ooh: "In Soviet Russia, trains catch YOU! "
23:53:56 <Figs> HAHAHA this guy is so full of shit
23:54:26 <Figs> "only a compiler or similar static analysis tool can verify that there are sufficient comments of sufficient semantic applicability to make the written code sufficiently clear to a novice to the language and problem domain."
23:55:24 <pikhq> Funny, I thought that only a human could do that.
23:56:29 <pikhq> Figs: A calculator can be written in the Game of Life. . .
23:56:39 <pikhq> After all, there is a Turing machine in it.