00:00:29 <ihope> oerjan: what?
00:01:20 <oerjan> e^x
00:01:52 <lament> and what's d(e^x)?
00:02:12 <oerjan> might be e^x dx
00:03:16 <lament> and what's dx?
00:03:49 <oerjan> d(e^x)/e^x
00:04:06 <ihope> Um, wait...
00:04:22 <oklopol> +-
00:04:33 <ihope> d(e^x) = e^x dx, indeed...
00:05:11 <ihope> oklopol: +-?
00:05:20 <oklopol> ihope: my keyboard fell.
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:06 <oklopol> hmm
00:06:10 <oklopol> well it was wrong :)
00:06:31 <oklopol> it isn't +- e^x dx
00:06:57 <oklopol> so... i owned my keyboard
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:07:27 <oklopol> err... i touch them?
00:08:02 <oerjan> yeww!
00:08:05 <oerjan> you pervert!
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:22:29 <bsmntbombdood> ihope: lisp
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:28:36 <pikhq> F=-GMm/WOLVES!
05:51:22 -!- Figs has joined.
05:51:30 <Figs> hey oklopol
05:51:33 <Figs> you around? :P
05:52:33 -!- nwf has quit ("Lost terminal").
06:03:08 <oklokok> now am
06:03:14 <oklokok> though back to sleep
06:03:16 <Figs> hi
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:03:47 <Figs> rofl :P
06:03:50 <Figs> yeah
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:50 <Figs> ok
06:04:51 <Figs> cya
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:40:59 <GreaseMonkey> leaving now, cya
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:13:45 <oklokok> not the only one
12:13:53 <oklokok> but onyl onish.
12:13:55 <oklokok> *only
12:14:42 <ehird`> sk-calculus#
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:15:39 <oklokok> i mean infinite 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:25 <ehird`> true
12:16:28 <oklokok> whereas in brainfuck that'd be 5, always.
12:16:33 <oklokok> well
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:25 <ehird`> indeed
12:17:26 <oklokok> because
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:18:26 <oklokok> don't remember
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:23 <oklokok> ehird`: what's gc'd?
12:29:29 <ehird`> garbage collected
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:37 <oklokok> :O
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:12 <ehird`> :(
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:04 <oklokok> ...
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:35:42 <oklokok> hmm
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:11 <oklokok> the program state
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:02 <oklokok> why?
12:38:06 <ehird`> memory usage
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:38:57 <ehird`> well, sure
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:51:50 <oklokok> well okay
12:51:56 <oklokok> not really
12:52:22 <oklokok> other way around
12:52:47 <ehird`> lambda-calculus :)
12:53:03 <oklokok> whut about it?
12:53:04 <ehird`> i'm parsing \x.\y.\z.xyz as x(yz) not (xy)z, right now
12:53:09 <oklokok> okay
12:53:11 <ehird`> stupid parsing.
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:10 <oklokok> (xy)z i guess
12:54:51 <ehird`> oklokok, because i'm hand-coding this.
12:54:59 <ehird`> also,
12:55:05 <ehird`> \xy.xy is being parsed as (\xy.x)y
12:55:09 <ehird`> which is ANNOYING MAXIMUM
12:55:12 <ehird`> *MAXIMUS
12:56:23 <oklopol> how's the problem left-recursion=
12:56:25 <oklopol> ?
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:01:11 <oklopol> well explained, oklo
13:01:12 <oklopol> ...
13:01:16 <oklopol> now, really, food ->
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 <ehird`> yes?
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:03 <ehird`> free their memory
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:37 <ehird`> no
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:25:04 <ehird`> (\x.x) -> Unmatched (
13:26:40 <ehird`> ahhhh i seee
13:26:44 <ehird`> hm
13:26:45 <ehird`> no i don't
13:39:04 -!- oerjan has joined.
13:42:17 <oklopol> hi örjan
13:42:34 <oerjan> hi oklopol
13:42:50 <oklopol> (i'd actually used your name if i were able to type that letter)
13:43:05 <oklopol> Ørjan
13:43:11 <oklopol> right?
13:43:36 <oerjan> i actually couldn't see if you were typing my name since i am not UTF8-clean
13:44:01 <oklopol> you dirty boy.
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:30 <oerjan> he he he
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:08:46 <ehird`> and xy
14:08:49 <ehird`> it's taking ages.
14:09:19 <oerjan> not even application?
14:10:27 <oklopol> ehird`: doesn't sound hard to do :|
14:10:38 <ehird`> oerjan, xy is application..
14:10:43 <oklopol> oerjan: ab == application
14:10:44 <ehird`> oklopol, sure - just tedious
14:10:46 <oklopol> ueah
14:10:53 <oklopol> i don't believe it is
14:11:03 <oklopol> i think it's < 15 lines in python
14:11:22 <oklopol> okay, <20
14:11:25 <oklopol> i'm not sure
14:12:21 <ehird`> ~320 lines of ruby right now
14:12:29 <oerjan> O_O
14:12:44 <oerjan> something is very wrong there
14:13:17 <oklopol> hehe
14:13:19 <oerjan> i was about to say < 5 lines in Haskell :)
14:13:25 <oklopol> ruby is no ordinary language xD
14:13:35 <oklopol> oh
14:13:40 <oklopol> ~320, i though -320
14:13:41 <oklopol> :D
14:14:07 <ehird`> err, wait
14:14:09 <ehird`> not 320 lines
14:14:10 <ehird`> 20 lines
14:14:12 <ehird`> XD
14:14:16 <oklopol> ah
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:19 <ehird`> OK rewrite time.
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:24:01 <ehird`> those are easy
14:31:11 <oklopol> parsing is fun :)
14:32:10 <ehird`> i highly doubt an LC parser could fit into 20 lines of python anyway
14:32:49 <oklopol> i'll try later
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:45:26 <DaFive> hi2all
14:46:20 -!- RodgerTheGreat has joined.
14:47:23 <RodgerTheGreat> hi guys
14:48:12 <DaFive> ðø
14:48:13 <DaFive> hi
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:17 <oklopol> hmm
15:12:34 <oklopol> how do you represent church numerals?
15:12:48 <oklopol> \f\f\f\f\f\fx?
15:13:07 <oklopol> err
15:13:09 <oklopol> i mean
15:13:16 <oklopol> \fx.fffffx
15:14:07 <ehird`> no
15:14:26 <ehird`> Church numeral N is \f x. (f^N)x
15:14:30 <oklopol> then how?
15:14:32 <ehird`> so 3 is \f x. f (f (f x))
15:14:36 <ehird`> and 0 is \f x. x
15:14:46 <ehird`> and 5 is \f x. f (f (f (f (f x))))
15:15:00 <oklopol> so exactly what i said
15:15:07 <oklopol> ah
15:15:08 <ehird`> no
15:15:20 <ehird`> \fx.fffx is \f x. ((f f) f) x
15:15:23 <ehird`> you need the parens
15:15:25 <oklopol> oh
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:15:56 <oklopol> i though you still were
15:16:02 <ehird`> i was describing a bug
15:16:13 <oklopol> yeah, indeed you were
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:27 <oklopol> oh
15:16:34 <oklopol> then i better do it someday xD
15:16:39 <oklopol> hmm, i'll do it now
15:17:50 <ehird`> :P
15:18:26 <ehird`> grammar: an identifier is any string but cannot contain a space, tab, newline, (, ), or \.
15:18:53 <oklopol> oh
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:09 <oklopol> since fx=fx.
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:27 <ehird`> oklopol, yeah
15:19:31 <ehird`> it should be \f x. f f f x
15:19:37 <ehird`> or \ f x. f f f x
15:19:42 <ehird`> or \f x.f f f x
15:20:07 <ehird`> or \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:36:54 <ehird`> :P
15:38:10 <oklopol> ehird`: am i allowed to use regexes? :)
15:38:20 <ehird`> possibly ;)
15:38:26 <ehird`> sure
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:47:40 <oklopol> hmm
15:47:44 <oklopol> gimme something to parse
15:48:04 <oklopol> i think i have it, 21 lines, no densing sone yet
15:48:07 <oklopol> *done
15:48:23 <ehird`> (\n f x. f (n f x)) \f x. f (f (f x))
15:48:27 <ehird`> and:
15:48:45 <ehird`> (\ n f x.(f((n f)x))\f x.f (f(f x))
15:48:48 <ehird`> are equivilent.
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:49:51 <ehird`> i'm impressed.
15:50:47 <ehird`> also:
15:51:03 <ehird`> \x.x\y.y is (\x. x (\y. y))
15:51:19 <ehird`> not (\x. x)(\y. y)
15:51:24 <ehird`> (because of the lambda-stretches-right rule)
15:53:31 <ehird`> and, of course:
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:06 <oklokok> *entirely
15:55:07 <ehird`> heh
15:55:10 <ehird`> "TOO MUCH PARSING!"
15:55:23 <oklokok> i love it how pyidle will just crash completely is i do an infinite loop
15:56:04 <ehird`> me no likey idle
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:47 <ehird`> =p
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:12:48 <oklokok> okay
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:03 <ehird`> oklokok, example?
16:20:06 <oklokok> function assignation works perfectly
16:20:11 <oklokok> your example was one
16:20:21 <oklokok> lambdas work if they aren't used
16:20:22 <oklokok> :)
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:20:37 <oklokok> your example was one
16:21:12 <ehird`> which example
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:22 <oklokok> i'll check
16:21:27 <oklokok> ehird`: that example.
16:21:34 <oklokok> that was your example
16:21:42 <ehird`> ok
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:48 <oklokok> yeah :)
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:08 <oklokok> *works not
16:22:13 <ehird`> right
16:22:19 <ehird`> what about  ((\ n f x.(f((n f)x))(\f x.f (f(f x))))
16:22:21 <oklokok> hmm
16:22:31 <oklokok> wait wait
16:22:38 <oklokok> anyway my point is that i have to leave soon
16:22:41 <ehird`> ok
16:22:42 <oklokok> :|
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:08 <oklokok> ehird`: i know my problem
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> becomes
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:48 <oklokok> ehird`: huh?
16:24:56 <ehird`> "x y z" -> ["apply", ["apply", "x", "y"], "z"]
16:25:03 <oklokok> no god 8|
16:25:10 <ehird`> it's simpler than just arrays
16:25:18 <oklokok> no it isn't
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:41 <ehird`> ouch.
16:25:45 <ehird`> that's ugly
16:25:50 <oklokok> i'm not gonna do that, i want a readable output
16:25:54 <oklokok> i mean, not your thing
16:26:18 <oklokok> if you know any lisp, you'll find mine good.
16:26:28 <ehird`> i know lots of lisp
16:26:37 <oklokok> then you do find it 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:13 <ehird`> macros are not LC
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:27:54 <oklokok> anyway
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:23 <ehird`> yes it is :)
16:28:39 <oklokok> that is as easy to machine-mangle as having "lambda" ther
16:28:40 <oklokok> *there
16:28:45 <oklokok> except mine is faster, of course
16:29:35 <ehird`> not really
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:33:35 <oklokok> ehird`: no.
16:33:54 <ehird`> :)
16:35:03 <oklokok> okay
16:35:07 <oklokok> i did what you wanted
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:35:10 <oklokok> hmm
16:35:17 <oklokok> anyway, is that right? :)
16:35:20 <oklokok> errr
16:35:22 <oklokok> can't be
16:35:26 <oklokok> sorry then
16:35:33 <oklokok> the lambda is wrong
16:35:37 <oklokok> like terribly wrong
16:35:45 <oklokok> oh my god it's wrong
16:39:52 <ehird`> that's... really wrong :P
16:40:25 <ehird`> i guess i'll parse unlambda-style for now
16:40:45 <ehird`> \f x. f x -> ^f^x$fx
16:40:48 <ehird`> ^ = lambda, $ = apply
16:44:34 <ehird`> %reload
16:44:36 <blahbot`> Reloaded.
16:44:47 <ehird`> %reload
16:44:48 <blahbot`> Reloaded.
16:44:52 <ehird`> %reduce ^f^x$fx
16:44:53 -!- blahbot` has quit (Remote closed the connection).
16:46:09 -!- blahbot` has joined.
16:46:13 <ehird`> %reduce ^f^x$fx
16:46:13 -!- blahbot` has quit (Remote closed the connection).
16:46:14 <oklokok> works
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:46:31 <oklokok> is that correct?
16:46:59 <ehird`> let me check
16:47:05 <oklokok> seems correct to me
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:38 <ehird`> ah :)
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:47:56 <oklokok> hmm
16:47:57 <oklokok> we'll see
16:48:27 -!- blahbot` has joined.
16:48:29 <oklokok> ['lambda', ['x'], ['apply', 'x', ['lambda', ['y'], 'y']]]
16:48:36 <ehird`> amazing
16:48:38 <ehird`> can i see the code?
16:48:44 <ehird`> %reduce ^f^x$fx
16:48:48 <ehird`> %reduce ^f^x$fx
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:03 <oklokok> 45 lines now
16:49:05 <ehird`> cool
16:49:13 <ehird`> currying isn't too hard really
16:49:16 <ehird`> just a few lines
16:50:51 * ehird` wants to see the code =)
16:50:58 <oklokok> http://www.vjn.fi/pb/p424155361.txt
16:51:02 <oklokok> you also need otools
16:51:33 <oklokok> it's not pretty, most would say, but it's pretty good code for the most part
16:52:23 <ehird`> otools?
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:52:56 <oklokok> err
16:52:57 <oklokok> huh?
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:31 <oklokok> parse_ski parses ski.
16:53:41 <oklokok> otools is used in parse_ski
16:54:14 <ehird`> but ... you're not parsing ski
16:54:17 <ehird`> you're parsing lc
16:54:39 <ehird`> %reduce ^xx
16:54:39 -!- blahbot` has quit (Remote closed the connection).
16:55:56 -!- blahbot` has joined.
16:55:57 <ehird`> %reduce ^f^x$fx
16:55:57 <blahbot`> [[:lambda, "f", ["x$fx", [:lambda, "", []]]]]
16:56:03 <ehird`> ehm o_O
16:57:00 <ihope> You call that reduction?
16:57:30 <ehird`> no
16:57:33 <ehird`> %reduce is currently %parse ;P
16:57:34 <blahbot`> ["is currently %parse ;P"]
16:57:37 <ehird`> heh.
16:57:43 <ihope> I see.
16:57:49 <ihope> Is $ apply?
16:57:53 <ehird`> yes
16:57:58 <ehird`> ^xy = \x.y
16:58:02 <ehird`> $xy = xy
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:24 <oklokok> it is
16:58:30 <ihope> Why am I saying :-P so much? :-P
16:58:30 <ehird`> because \f\x$fx looks ugly
16:58:35 <ehird`> hah
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:40 <oklokok> ehird`: i'm parcing lc?
16:58:42 <ihope> Does \f\x`fx look ugly?
16:58:45 <oklokok> that's that mean?
16:58:50 <ehird`> oklokok, you're parsing lambda calculus
16:58:54 <ehird`> not ski calculus
16:58:56 <ehird`> so parse_ski?
16:59:01 <oklokok> ah
16:59:05 <oklokok> well, sorry
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:31 <oklokok> since i was in a hurry
16:59:43 <ehird`> ihope, How?
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:15 <ehird`> e.g.
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:50 <oklokok> okay
17:00:51 <ihope> Use \ to denote a pattern, and have free variables just be part of the type.
17:00:51 <oklokok> good
17:00:58 <oklokok> bye all!
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:01 * ihope ponders
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:13 <ehird`> x <- y is variables
17:04:18 <ehird`> {x} is lambdas
17:04:25 <ehird`> => is pairs
17:04:32 <ehird`> x=>y is the pair like lispish (x . y)
17:04:38 <ehird`> -> is if
17:04:45 <ehird`> (x => y) -> z
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:13 <ehird`> x => y -> a => b -> c
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:08 <ehird`> aka fib
17:06:16 -!- sebbu has joined.
17:06:20 <ehird`> parse THAT!
17:06:29 <ehird`> (harder: evaluate THAT!)
17:06:38 <ehird`> %reduce ^xx
17:06:39 <blahbot`> [[:lambda, "xx", []]]
17:06:48 <ehird`> %reduce ^x x
17:06:48 <blahbot`> [[:lambda, "x x", []]]
17:07:06 <ehird`> %reload
17:07:06 <blahbot`> Reloaded.
17:07:07 <ehird`> %reduce ^x x
17:07:08 -!- blahbot` has quit (Remote closed the connection).
17:07:44 -!- blahbot` has joined.
17:07:45 <ehird`> %reduce ^x x
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:09:55 <ehird`> %reduce ^x x
17:09:56 <ihope> :-)
17:10:06 <ehird`> especially (s => b) -> a
17:10:10 <ehird`> :P
17:10:16 <ihope> Also, I seem to be using -> for multiple things.
17:10:22 <ehird`> %reload
17:10:22 <blahbot`> Reloaded.
17:10:24 <ehird`> %reduce ^x x
17:10:24 <blahbot`> [[:lambda, "x", ["x "]]]
17:10:27 <ehird`> HURAY
17:10:42 <ihope> And I'm capitalizing inconsistently.
17:10:43 <ehird`> %reduce ^x$x
17:10:44 <blahbot`> [[:lambda, "x$x", []]]
17:10:46 <ehird`> %reduce ^x$xy
17:10:46 <blahbot`> [[:lambda, "x$xy", []]]
17:10:48 <ehird`> grr
17:10:53 <ehird`> %reload
17:10:54 <blahbot`> Reloaded.
17:10:55 <ehird`> %reduce ^x$xy
17:10:56 <blahbot`> [[:lambda, "x", ["xy$"]]]
17:10:57 <ehird`> %reduce ^x$x y
17:10:58 <ihope> If (->) is defined appropriately, then "
17:11:00 <blahbot`> [[:lambda, "x", ["x y$"]]]
17:11:00 <ihope> Er.
17:11:30 <ihope> If (->) is defined appropriately, then "\x -> x + 3" becomes an expression rather than special syntax.
17:11:35 <ehird`> %reload
17:11:35 <blahbot`> Reloaded.
17:11:41 <ehird`> ihope, clever
17:12:03 <ehird`> but not as clever as... THE ARBITARY PARSERORNATOR
17:12:05 <ehird`> %reduce ^x$x y
17:12:05 <blahbot`> [[:lambda, 120, [[:apply, ["x", " ", "y"], []]]]]
17:12:07 <ehird`> %reduce ^x$xy
17:12:07 <ihope> Case/of expressions can also be defined.
17:12:07 <blahbot`> [[:lambda, 120, [[:apply, ["x", "y"], []]]]]
17:12:13 <ehird`> %reload
17:12:13 <blahbot`> Reloaded.
17:12:14 <ehird`> %reduce ^x$xy
17:12:15 <blahbot`> [[:lambda, "x", [[:apply, ["x", "y"], []]]]]
17:12:20 <ihope> THE ARBITRARY PARSERORNATOR?
17:12:32 <ehird`> yes
17:12:38 <ihope> Matrioshkaness?
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:12:53 <ehird`> yes.
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:14 <ihope> Fun.
17:13:25 <ihope> Again, reminds me of a... language?
17:13:29 <ehird`> called lisp? heh.
17:13:39 <ihope> No, not that.
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:14:25 <ihope> (Cool.)
17:15:07 <ihope> [ adds syntax, \ escapes, ] removes syntax.
17:15:21 <ehird`> heh
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 <ehird`> %reduce ^x$xy
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:16:20 <ehird`> Recursive blends! :)
17:17:03 <ehird`> %reload
17:17:03 <blahbot`> Reloaded.
17:17:04 <ehird`> %reduce ^x$xy
17:17:05 <blahbot`> [:lambda, "x", [:apply, "x", "y"]]
17:17:07 <ehird`> hooray
17:17:13 <ehird`> %reduce ^f^x$f$fx
17:17:14 <blahbot`> [:lambda, "f", [:lambda, "x", [:apply, "f", [:apply, "f", "x"]]]]
17:17:28 <ehird`> %reduce $^x$xx^x$xx
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:41 <ehird`> cool
17:18:55 <ehird`> maybe i should implement that blend someday
17:22:57 -!- oklokok has quit (Connection timed out).
17:26:00 <ehird`> %reload
17:26:01 <blahbot`> Reloaded.
17:26:08 <ehird`> %reduce ^f^x$f$fx
17:28:03 <ehird`> %reload
17:28:03 <blahbot`> Reloaded.
17:28:04 <ehird`> %reduce ^f^x$f$fx
17:28:28 <ehird`> %ps
17:28:28 <blahbot`> 0. ps
17:28:30 <ehird`> %reload
17:28:31 <blahbot`> Reloaded.
17:28:41 <ehird`> %reduce ^f^x$f$fx
17:28:55 <ehird`> %quit
17:28:56 -!- blahbot` has quit (Remote closed the connection).
17:29:13 -!- blahbot` has joined.
17:29:15 <ehird`> %reduce ^f^x$f$fx
17:29:32 <ehird`> %reload
17:29:33 <blahbot`> Reloaded.
17:29:33 <ehird`> %reduce ^f^x$f$fx
17:29:34 <blahbot`> ^f^x$f$fx
17:29:59 <ehird`> %reduce $^n^f^x$f$$nfx^f^x$fx
17:30:51 <ehird`> %reload
17:30:51 <blahbot`> Reloaded.
17:30:52 <ehird`> %reduce $^n^f^x$f$$nfx^f^x$fx
17:30:52 <blahbot`> ^f^x$f$$^f^x$fxfx
17:31:22 <ehird`> hooray
17:31:32 <ehird`> %reduce l
17:31:48 <ehird`> %reduce ^xl
17:31:48 <blahbot`> ^xl
17:32:24 <ehird`> %reload
17:32:24 <blahbot`> Reloaded.
17:32:25 <ehird`> %reduce ^xl
17:32:26 <blahbot`> ^xl
17:32:26 <ehird`> %reduce l
17:32:27 <blahbot`> l
17:32:31 <ehird`> %reduce $^xl^xl
17:32:32 <blahbot`> l
17:32:51 <ehird`> %reduce ^g$^x$g$xx^x$g$xx
17:32:52 <blahbot`> ^g$^x$g$xx^x$g$xx
17:32:57 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:34:08 <ehird`> %reload
17:34:09 <blahbot`> Reloaded.
17:34:09 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:34:09 <blahbot`> ^g$^x$f$xx^x$f$xx
17:34:16 <ehird`> Hmmm
17:34:22 <ehird`> %reload
17:34:23 <blahbot`> Reloaded.
17:34:24 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:34:40 <ehird`> %reload
17:34:41 <blahbot`> Reloaded.
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:08 <ehird`> %reload
17:35:09 <blahbot`> Reloaded.
17:35:09 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:35:24 <ehird`> %reload
17:35:24 <blahbot`> Reloaded.
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 <ehird`> %ps
17:36:19 <blahbot`> 0. reduce $^g$^x$g$xx^x$g$xx^g$^x$g$xx^x$g$xx
17:36:19 <blahbot`> 1. ps
17:36:23 <ehird`> well, (Y Y) works.
17:36:24 <ehird`> %kill 0
17:36:36 <ehird`> %reduce $^xxf
17:36:36 <blahbot`> f
17:36:42 <ehird`> %reduce $^x$xyf
17:36:44 <ehird`> %ps
17:36:44 <blahbot`> 0. ps
17:36:47 <ehird`> I see the problem.
17:36:58 <ehird`> $ never gives up
17:38:40 <ehird`> %reduce x
17:38:40 <blahbot`> x
17:38:42 <ehird`> %reduce $xx
17:38:43 -!- blahbot` has quit (Remote closed the connection).
17:41:57 -!- blahbot` has joined.
17:42:00 <ehird`> %reduce l
17:42:00 <blahbot`> l
17:42:04 <ehird`> %reduce $^xxl
17:42:04 <blahbot`> l
17:42:09 <ehird`> %reduce $^x^yxl
17:42:09 <blahbot`> ^yl
17:42:21 <ehird`> %reduce $^x^y$xyll
17:42:21 <blahbot`> ^y$ly
17:42:28 <ehird`> %reduce $$^x^y$xyll
17:42:28 <blahbot`> $ll
17:42:31 <ehird`> hooray.
17:42:58 <ehird`> %reduce $^n^f^x$f$$nfxn
17:42:58 <blahbot`> ^f^x$f$$nfx
17:46:03 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:46:03 <blahbot`> $^x$f$xx^x$f$xx
17:46:10 <ehird`> Hm.
17:46:47 <ehird`> That should be $f$^x$f$xx^x$f$xx, shouldn't it?
17:46:56 <ehird`> (opinions needed :))
17:52:37 <ehird`> %reload
17:52:37 <blahbot`> Reloaded.
17:52:41 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:52:41 <blahbot`> $^x$f$xx^x$f$xx
17:53:00 <ehird`> hmm
17:53:05 <ehird`> that's just one reduction isn't it
17:54:29 <ehird`> %reload
17:54:29 <blahbot`> Reloaded.
17:54:30 <ehird`> that's just one reduction isn't it
17:54:32 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
17:54:32 <blahbot`> $^x$f$xx^x$f$xx
17:54:45 <ehird`> %reload
17:54:45 <blahbot`> Reloaded.
18:18:32 <ihope> %reduce $^g$^x$g$xx^x$g$xxf
18:18:32 <blahbot`> $^x$f$xx^x$f$xx
18:31:49 <ehird`> hmm
18:31:52 <ehird`> is that right?
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:32:25 <blahbot`> $f$^x$f$xx^x$f$xx
18:33:35 <ehird`> %reload
18:33:35 <blahbot`> Reloaded.
18:33:37 <ehird`> %reduce $^x$f$xx^x$f$xx
18:33:37 <blahbot`> $f$^x$f$xx^x$f$xx
18:33:45 <ehird`> Hmm.
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:06 <blahbot`> $^x$f$xx^x$f$xx
18:34:15 <ehird`> %reduce $^x$f$xx^x$f$xx
18:34:15 <blahbot`> $f$^x$f$xx^x$f$xx
18:34:30 <ehird`> %reloa
18:34:31 <ehird`> %reload
18:34:31 <blahbot`> Reloaded.
18:34:33 <ehird`> %reduce $^g$^x$g$xx^x$g$xxf
18:34:33 <blahbot`> $^x$f$xx^x$f$xx
18:34:37 <ehird`> Meh.
18:34:46 <ehird`> %reload
18:34:47 <blahbot`> Reloaded.
18:34:51 <ehird`> Back to call-by-name.
18:35:02 <ehird`> %reduce $^x$xx^x$xx
18:35:02 <blahbot`> $^x$xx^x$xx
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:23 <blahbot`> ^b$$b^x^yx^x^yy
18:37:50 <ehird`> %reduce $^p$p^x^yx$$^f^s^b$$bfs^x^yx^x^yy
18:37:50 <blahbot`> $$$^f^s^b$$bfs^x^yx^x^yy^x^yx
18:38:06 <ehird`> %reload
18:38:06 <blahbot`> Reloaded.
18:38:07 <ehird`> %reduce $^p$p^x^yx$$^f^s^b$$bfs^x^yx^x^yy
18:38:07 <blahbot`> $^b$$b^x^yx^x^yy^x^yx
18:38:14 <ehird`> %reduce $^b$$b^x^yx^x^yy^x^yx
18:38:14 <blahbot`> $$^x^yx^x^yx^x^yy
18:38:19 <ehird`> %reduce $$^x^yx^x^yx^x^yy
18:38:19 <blahbot`> ^x^yx
18:38:33 <ehird`> %reload
18:38:33 <blahbot`> Reloaded.
18:38:36 <ehird`> %reduce $^p$p^x^yx$$^f^s^b$$bfs^x^yx^x^yy
18:38:36 <blahbot`> $^b$$b^x^yx^x^yy^x^yx
18:38:40 <ehird`> %reduce $^b$$b^x^yx^x^yy^x^yx
18:38:40 <blahbot`> $$^x^yx^x^yx^x^yy
18:38:46 <ehird`> %reduce  $$^x^yx^x^yx^x^yy
18:38:51 <ehird`> %reduce $$^x^yx^x^yx^x^yy
18:38:51 <blahbot`> ^x^yx
18:39:11 <ehird`> %reduce $^g$^x$g$xx^x$g$xx^x^yx
18:39:11 <blahbot`> $^x$^x^yx$xx^x$^x^yx$xx
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:00 <ehird`> hmmm .. maybe note
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:13 <ehird`> interesting
18:40:20 <ehird`> lament, what do you think?
18:40:26 <ehird`> %reload
18:40:26 <blahbot`> Reloaded.
18:40:31 <ehird`> %reduce $^g$^x$g$xx^x$g$xx^x^yx
18:40:31 <blahbot`> $^x$^x^yx$xx^x$^x^yx$xx
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:51 <ehird`> %reload
18:45:52 <blahbot`> Reloaded.
18:45:54 <ehird`> %reduce $^g$^x$g$xx^x$g$xx^x^yx
18:45:55 <blahbot`> $^x$^x^yx$xx^x$^x^yx$xx
18:45:58 <ehird`> grrr
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:52 <blahbot`> $^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:09 <ehird`> %reduce $^xxa
18:48:11 <ihope> A change between two reductions?
18:48:18 <ehird`> ihope, x != reduce(x)
18:48:22 <ehird`> in pseudocode:
18:48:36 <ehird`> while x has free variables and x != reduce(x), set x = reduce(x)
18:49:03 <ehird`> %ps
18:49:03 <blahbot`> 0. reduce $^xxa
18:49:03 <blahbot`> 1. ps
18:49:05 <ehird`> %kill 0
18:49:27 <ehird`> %reload
18:49:27 <blahbot`> Reloaded.
18:49:32 <ehird`> %reduce $^xxa
18:49:33 <blahbot`> a
18:49:35 <ehird`> success
18:49:42 <ehird`> %reduce $^x^y$xyab
18:49:42 <blahbot`> ^y$ay
18:49:49 <ehird`> %reduce $$^x^y$xyab
18:49:49 <blahbot`> $ab
18:49:52 <ehird`> success!
18:50:00 <ehird`> %reduce $^x^y$xy$ab
18:50:00 <blahbot`> ^y$ay
18:50:10 <ehird`> %reduce $$^x^y$xy$abc
18:50:10 <blahbot`> $ac
18:50:14 <ehird`> hmmmmmm
18:50:18 <ehird`> %reduce $ab
18:50:18 <blahbot`> a
18:50:22 <ehird`> interesting
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:35 <blahbot`> $^x$^x^yx$xx^x$^x^yx$xx
18:50:38 <ehird`> hrm.
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:53:39 <ehird`> %reduce $^x$xxa
18:53:39 <blahbot`> $aa
18:53:48 <ehird`> %reduce $^x$xx^xaa
18:53:48 <blahbot`> $^xa^xa
18:53:51 <ehird`> %reduce $^x$xx^x$aa
18:53:51 <blahbot`> $^x$aa^x$aa
18:54:22 <ehird`> %reduce $^n^f^x$f$$nfxa
18:54:22 <blahbot`> ^f^x$f$$afx
18:54:28 <ehird`> %reduce $^n^f^x$f$$nfx$ab
18:54:28 <blahbot`> ^f^x$f$$afx
18:54:32 <ehird`> %reduce $^n^f^x$f$$nfx$a$bc
18:54:32 <blahbot`> ^f^x$f$$afx
18:54:34 <ehird`> hmm
18:54:40 <ehird`> >why< does $ab -> a
18:55:51 <ehird`> %reduce $ab
18:55:51 <blahbot`> a
18:56:07 <ehird`> hm
18:56:27 <ehird`> aha
18:56:58 <ehird`> %reload
18:56:58 <blahbot`> Reloaded.
18:56:59 <ehird`> %reduce $ab
18:56:59 <blahbot`> a
18:57:15 <ehird`> %reload
18:57:15 <blahbot`> Reloaded.
18:57:16 <ehird`> %reduce $ab
18:57:18 <ehird`> %ps
18:57:19 <blahbot`> 0. ps
18:57:36 <ehird`> %reload
18:57:36 <blahbot`> Reloaded.
18:57:37 <ehird`> %reduce $ab
18:57:40 <ehird`> %ps
18:57:40 <blahbot`> 0. ps
18:57:57 <ehird`> %reload
18:57:57 <blahbot`> Reloaded.
18:57:58 <ehird`> %reduce $ab
19:00:18 <ehird`> :/
19:04:31 <ehird`> %reduce a
19:04:31 <blahbot`> a
19:04:33 <ehird`> %reduce ab
19:04:33 <blahbot`> a
19:04:35 <ehird`> %reduce b
19:04:36 <blahbot`> b
19:04:40 <ehird`> %reduce ^x$ab
19:04:40 <blahbot`> ^x$ab
19:04:45 <ehird`> %reduce $^x$abx
19:04:45 <blahbot`> $ab
19:04:49 <ehird`> %reduce $ab
19:27:39 -!- andreou has joined.
19:43:32 -!- oerjan has joined.
19:49:04 <ehird`> %reduce $^x$abx
19:49:04 <blahbot`> $ab
19:49:08 <ehird`> %reduce $ab
19:49:18 <ehird`> %reduce $b
19:49:19 <ehird`> %reduce $ba
19:49:22 <ehird`> %reduce b
19:49:23 <blahbot`> b
19:50:01 <ehird`> :/
19:56:31 <ihope> Reduce until it changes?
20:00:37 -!- Sgeo has joined.
20:00:48 <ehird`> ihope, No
20:00:53 <ehird`> reduce until it doesn't change
20:01:33 <ihope> Hmm.
20:01:35 <ehird`> %reload
20:01:35 <blahbot`> Reloaded.
20:01:37 <ehird`> %reduce b
20:01:37 <blahbot`> b
20:01:39 <ihope> What are your rules for reduction?
20:01:39 <ehird`> %reduce $ab
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:04 <ehird`> kind of.
20:02:23 <ehird`> i don't rename variables, i just replace each occurence of them with the argument's value, assap
20:02:24 <ehird`> *asap
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:16 <ehird`> ihope, Pretty much
20:03:19 <ehird`> %reload
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:42 <ehird`> ihope, Anywhere
20:03:45 -!- blahbot` has joined.
20:03:47 <ehird`> %reduce a
20:03:48 <blahbot`> a
20:03:55 <ehird`> %reduce $^x.x^x.x
20:03:56 <blahbot`> .
20:03:58 <ehird`> ...
20:03:59 <ehird`> wtf.
20:04:00 <ehird`> oh.
20:04:03 <ehird`> %reduce $^xx^xx
20:04:03 <blahbot`> ^xx
20:04:15 <ehird`> %reduce $^x$^xxx^xx
20:04:16 <blahbot`> $^x^xx^xx
20:04:20 <ehird`> that's not right.
20:04:32 <ehird`> %reduce $^x^xx^xx
20:04:32 <blahbot`> ^x^xx
20:04:41 <ehird`> hmmmmmmmmm, oh wait
20:04:53 <ehird`> %reduce $^x$^xxx^xx
20:04:53 <blahbot`> $^x^xx^xx
20:05:17 <ehird`> %reduce $^x$^xxx^xx
20:05:18 <blahbot`> $^x^xx^xx
20:05:25 <ehird`> ok so maybe i need alphaconversion
20:05:29 <ehird`> %reduce $^x$^yyx^xx
20:05:29 <blahbot`> $^yy^xx
20:05:38 <ehird`> why isn't that reducing further.
20:05:42 <ehird`> %reduce $^yy^xx
20:05:43 <blahbot`> ^xx
20:05:45 <ehird`> i mean - it can
20:05:47 <ehird`> so why isn't it.
20:06:29 <ehird`> %reload
20:06:29 <blahbot`> Reloaded.
20:06:32 <ehird`> %reduce $^x$^yyx^xx
20:06:33 <blahbot`> $^yy^xx
20:06:37 <ehird`> grr
20:07:12 <ehird`> (\x.(\x.x)x)y should be y, right? :/
20:07:35 <ehird`> %reduce $^x$^xxxy
20:07:35 <blahbot`> $^xyy
20:08:05 <ehird`> %reload $^xyy
20:08:08 <ehird`> er
20:08:09 <ehird`> %reduce y
20:08:10 <blahbot`> y
20:08:13 <ehird`> %reduce $^xyy
20:08:13 <blahbot`> y
20:08:25 <ehird`> %reduce $^x$^xxxx
20:08:25 <blahbot`> $^xxx
20:08:29 <ehird`> %reduce $^xxx
20:08:30 <blahbot`> x
20:08:37 <ehird`> %reload
20:08:38 <blahbot`> Reloaded.
20:08:38 <ehird`> %reduce $^x$^xxxx
20:08:39 <blahbot`> $^xxx
20:08:41 <ehird`> %reduce $^xxx
20:08:42 <blahbot`> x
20:08:45 <ehird`> ok so that works
20:08:52 <ehird`> %reduce $$^x$^xxxxy
20:08:53 -!- blahbot` has quit (Remote closed the connection).
20:09:01 <ehird`> that should be $xy
20:09:35 -!- blahbot` has joined.
20:09:37 <ehird`> %reduce $$^x$^xxxxy
20:09:45 <ehird`> %reduce $$^x$^xxxxy
20:09:48 <ehird`> %reduce $$^x$^xxxxy
20:09:49 <ehird`> %reduce $$^x$^xxxxy
20:09:49 <ehird`> %reduce $$^x$^xxxxy
20:09:49 -!- blahbot` has quit (Remote closed the connection).
20:09:51 <ehird`> damnit
20:09:53 <ehird`> no debug
20:10:03 <ihope> What language is this in?
20:10:10 <ehird`> the interp?
20:10:12 <ehird`> the interp is in ruby
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 <ehird`> %reduce $$^x$^xxxxy
20:10:42 <pikhq> Rubys are bad for you, mmkay?
20:10:50 <ehird`> oh shush
20:10:57 <ehird`> x
20:11:00 <ehird`> %quit
20:11:01 -!- blahbot` has quit (Client Quit).
20:11:02 <pikhq> NEVER!!!
20:11:17 <pikhq> puts "Says this little Tcl/Ruby polyglot (I think)."
20:11:21 -!- blahbot` has joined.
20:11:43 <ehird`> yes it is
20:11:46 <ehird`> %reduce $$^x$^xxxxy
20:12:10 <ehird`> %reload
20:12:10 <blahbot`> Reloaded.
20:12:12 <ehird`> %reduce $$^x$^xxxxy
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:12:59 <ehird`> %reload
20:13:00 <blahbot`> Reloaded.
20:13:01 <ehird`> %reduce $$^x$^xxxxy
20:13:01 -!- blahbot` has quit (Remote closed the connection).
20:13:04 <ehird`> garrrr
20:13:20 <pikhq> [apply {y {return $x}}] There. Happy?
20:13:33 <ehird`> heh
20:13:37 -!- blahbot` has joined.
20:13:39 <ehird`> %reduce $$^x$^xxxxy
20:14:17 <ehird`> %reload
20:14:17 <blahbot`> Reloaded.
20:14:18 <ehird`> %reduce $$^x$^xxxxy
20:14:18 <blahbot`> $yx
20:14:30 <ehird`> %reduce $^xxx
20:14:30 <blahbot`> x
20:14:36 <ehird`> %reduce $$^xxx$^xxy
20:14:36 <blahbot`> $x$^xxy
20:14:42 <ehird`> not ideal.
20:14:50 <ehird`> %reload
20:14:50 <blahbot`> Reloaded.
20:14:51 <ehird`> %reduce $$^xxx$^xxy
20:14:51 <blahbot`> $xy
20:14:54 <ehird`> ideal!
20:14:56 <ehird`> HOORAY!
20:14:59 * ihope claps
20:15:14 <andreou> make it say "oh andreou is so sexy"
20:15:26 <ihope> oh andreou is so sexy
20:15:40 <blahbot`> oh andreou is not
20:15:54 <ihope> Woot.
20:16:00 <ihope> Is is is is is.
20:16:44 <ehird`> %reduce $^x$^xxx^xx
20:16:44 <blahbot`> $^x^xx^xx
20:16:47 <ehird`> GRRR
20:16:49 <ehird`> that should be ^xx
20:16:56 <ehird`> %reduce $^x^xx^xx
20:16:57 <blahbot`> ^x^xx
20:17:03 <ehird`> wtf.
20:17:15 <ehird`> hmm
20:17:41 <ehird`> (\x.(\x.something x)something)abc shouldn't be (\x.something abc)something
20:17:43 <ehird`> should it?
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:23 <ehird`> %reduce $^x$^yyx^xx
20:20:23 <blahbot`> $^yy^xx
20:20:31 <ehird`> ^ why doesn't that reduce to ^xx!?!!
20:21:00 <ehird`> %reduce $^x$^yyxA
20:21:00 <blahbot`> $^yyA
20:21:08 <ihope> %reduce $^yy^xx
20:21:09 <blahbot`> ^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:20 <ehird`> %reduce $^f^x$fx^yx
20:28:21 <blahbot`> ^x$^yxx
20:28:31 <ehird`> %reduce $^x$^yxxA
20:28:32 <blahbot`> $^yAA
20:28:38 <ehird`> %reduce $^yAA
20:28:38 <blahbot`> A
20:28:45 <ehird`> that SHOULD all be done in one step.
20:28:50 <ehird`> well
20:28:52 <ehird`> not really
20:28:57 <ehird`> the last two steps should be combined
20:35:17 <ehird`> :/
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:51:14 <ehird`> hmm
21:52:17 <SimonRC> j0
21:52:48 <lament> harry potter kills voldemort with brainfuck!
21:53:15 <SimonRC> :-D
21:53:26 <SimonRC> "Harry, I am your mother."
21:53:32 <SimonRC> "I meant father."
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:57:57 <Figs> HP7?
21:58:02 <ehird`> Figs, obviously
21:58:03 <SimonRC> yeah
21:58:20 <SimonRC> I know!
21:58:31 <Sukoshi> Gah. Static languages.
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:51 <SimonRC> In some order
21:58:51 <Figs> rofl
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:15 <Sukoshi> Java :(
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
21:59:54 <SimonRC> grr
21:59:57 <Figs> O.o
22:00:00 <SimonRC> ehird`: heh
22:00:04 <ehird`> ^ THAT'S WHY IT DIDN'T KILL HIM!
22:00:10 <ehird`> dun dun DUNNNNNNN
22:00:20 * ehird` will obviously turn out to be completely right
22:00:22 <Figs> .... o.O
22:00:24 <Figs> rofl
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:42 <ehird`> Sukoshi, o_O
22:00:47 <ehird`> SimonRC, hah
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:27 <SimonRC> Figs: really?
22:01:32 <Figs> as long as he lives
22:01:34 <ehird`> <real spoilers start>
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:12 <pikhq> /ignore ehird`
22:02:13 <SimonRC> Tritonio: WRU
22:02:20 <ehird`> somebody tell pikhq that i didn't mean me
22:02:27 <SimonRC> ehird`: actually....
22:02:28 <bsmntbombdood> heh
22:02:33 <SimonRC> that's a good idea...
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:05 <ehird`> haha
22:03:10 <oerjan> crackpottering?
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:39 <SimonRC> etc
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:49 <Figs> rofl
22:03:49 <SimonRC> heh
22:03:56 <ehird`> pikhq, maybe that's why it took so long
22:04:03 <pikhq> Could be.
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:31 <SimonRC> Figs: ITYM "hallows"
22:04:35 <Figs> yeah
22:04:36 <bsmntbombdood> depends if it's the erotic sort or not
22:04:36 <Figs> I can't spell
22:04:38 <Figs> :P
22:04:42 <Figs> o.o
22:04:45 <Sukoshi> pikhq: You *read* Harry Potter?
22:04:51 <Sukoshi> And, erm, enjoy it?
22:04:55 <lament> Figs: i don't see how the illustration spoils it in any way...
22:05:04 <Figs> illustrator
22:05:06 <pikhq> Yuh.
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:16 <Sukoshi> ehird`: That's the point.
22:05:18 <lament> Figs: you've talked to the illustrator?
22:05:18 <Figs> one who illustrates
22:05:19 <Figs> no
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:05:50 <SimonRC> like LOLCODE was
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:41 <bsmntbombdood> lolcode was so dumb
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:54 <Figs> bah
22:06:55 <Figs> :P
22:06:58 <Figs> *Baltimore Sun
22:06:59 <Figs> there
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:07:59 <Figs> lol
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:23 <SimonRC> pikhq: yup
22:08:24 <bsmntbombdood> some people just read for fun
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:09:48 <bsmntbombdood> you guys have all seen the leak, right?
22:09:51 <SimonRC> yup
22:09:54 <SimonRC> IW Rox
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:26 <pikhq> :(
22:10:35 <Figs> I haven't seen the leak, no
22:10:40 <Figs> heard of it yes
22:10:52 <bsmntbombdood> IW?
22:10:53 <Figs> no way in fucking hell am I touching that download :P
22:11:02 <bsmntbombdood> Figs: why not?
22:11:11 <bsmntbombdood> someone should transcribe it to ascii :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:41 <ehird`> pikhq, i dunno
22:12:46 <Figs> I know. Rare for my to buy things.
22:12:54 <bsmntbombdood> lament: why?
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:39 <SimonRC> :-P
22:14:42 <Figs> lol
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:15:58 <SimonRC> heh
22:16:54 <ehird`> http://qntm.org/icecubes
22:17:07 <ehird`> =p
22:17:59 <SimonRC> ice cubes aren't tasty!
22:18:32 <ehird`> yes they are
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:21:15 <Figs> o.O
22:22:09 <Figs> ehird`, you've seen the lego babbage machines, right?
22:22:18 <ehird`> Figs, you're joking.
22:22:20 <ehird`> do they actually work
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:09 <ehird`> wow
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>  
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:26:32 <Figs> *K'NEX
22:26:59 <Figs> ohh
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:53 <ehird`> oh:
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:27:57 <ehird`> damn.
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:28:38 <Figs> :P
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:33 <Figs> *robot
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:31 <Figs> :P
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:33:42 <pikhq> Yup. ;)
22:33:56 <ehird`> well then :P
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:11 <ehird`> liber, no
22:34:13 <ehird`> x[y]z
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:32 <ehird`> Sukoshi, indeed
22:34:34 <liber> when the loop ends it stays where it was when the loop ended
22:34:41 <Sukoshi> Yup.
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:11 <ehird`> so what
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:20 <ehird`> good code that is.
22:36:29 <oerjan> inget problem :)
22:36:31 <pikhq> Where's a Swede when you need one? :p
22:36:31 <liber> hehehe
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:01 <liber> ruby
22:37:03 <ehird`> mainly my code explains itself
22:37:10 <ehird`> i can handle ruby :P
22:37:15 * pikhq is antiRuby
22:37:26 * ehird` is antiRubyButItISPracticalAndUseful
22:38:39 * lament is anti-camelcase
22:38:53 * ehird` is anti-fnord
22:38:57 -!- DeviALT has joined.
22:39:07 <Figs> I emailed the guy from IOCC
22:39:10 <pikhq> [set Tcl "FTW"]
22:39:10 <Figs> *IOCCC
22:39:12 <Figs> no reply yet
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 <Figs> oh!
22:39:37 <liber> http://pastebin.se/24992
22:39:41 <Figs> no I did get a reply
22:39:44 <Figs> !!
22:39:44 <Figs> :D
22:39:53 <lament> the best language for writing a brainfuck implementation is of course HQ9+B
22:39:57 <ehird`> liber, let's see...
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:31 <ehird`> just do getc.char
22:40:33 <ehird`> *chr
22:40:34 <ehird`> not gets[0]
22:40:36 <liber> well
22:40:41 <Figs> and he said he didn't know of any Obfuscated C++ contests either :P
22:40:45 <liber> no
22:41:04 <ehird`> actually this code is just insane. :P
22:41:05 <lament> Figs: start your own.
22:41:10 <ehird`> liber, well yes
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:41:29 <ehird`> yes
22:41:31 <ehird`> that is how BF works.
22:41:51 <liber> oh
22:42:03 <liber> so the newline is supposed to be "loaded"?
22:42:08 <DeviALT> IRP is scary and frightening.
22:42:28 <Figs> O_O
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:42:52 <DeviALT> haha
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:46 <liber> bassoon
22:44:52 <lament> sweet!
22:44:56 <oerjan> Please worble glak moofle "Hello, world!"
22:44:57 <lament> that makes it easier.
22:45:08 <lament> Hello, world!
22:45:11 <Figs> I play flute. Are we forming a band?
22:45:27 <lament> Yo toco mujeres.
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:51 <Figs> Sea Bass :_
22:46:52 <Figs> :)
22:46:57 <liber> That's just creapy
22:47:04 <Figs> me?
22:47:05 <RodgerTheGreat> hey, cool. Checkers has been solved.
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:34 <RodgerTheGreat> Figs: that's a much harder proof
22:47:40 <RodgerTheGreat> lol
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:14 <RodgerTheGreat> a complete game tree has been built
22:48:16 <lament> RodgerTheGreat: do any intellectuals still play chess? I thought they all switched to Go.
22:48:25 <liber> Go <3
22:48:28 <RodgerTheGreat> many have switched to go
22:48:28 <pikhq> lament: Yeah, quite a few do.
22:48:37 <DeviALT> more like go away >:[
22:48:55 <pikhq> liber: How does your program handle ">,[>,]<[.<]"?
22:49:04 <liber> 2 secs
22:49:04 <Figs> oh
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:35 <Figs> rofl
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:35 <pikhq> Yeah.
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:44 <liber> and loops
22:51:50 <pikhq> liber: Odd.
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:52:39 <liber> EOF?
22:52:42 <pikhq> End of file.
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:12 * Figs shuffles off
22:54:16 <Figs> but eh
22:54:24 <Figs> typically, you shouldn't call us AI
22:54:29 <liber> pikhq: how do I input EOF?
22:54:41 <pikhq> UNIX? Windows?
22:54:44 <liber> unix
22:54:47 <liber> linux*
22:54:52 <pikhq> Ctrl-D
22:54:52 <liber> same shit
22:54:54 <liber> ah
22:54:58 <liber> whell
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:32 <Figs> NINNYs
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:40 <lament> *true
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:16 <liber> oerjan: aah!
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:46 <Figs> no
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:00 <ehird`> nil != 0
22:57:01 <Figs> it's just a "bad" joke then :)
22:57:02 <ehird`> = infinite loop
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:57:53 <liber> ehird`: mean!
22:58:01 <ehird`> not really :p
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:02:42 <RodgerTheGreat> bingo
23:03:55 <lament> there's nothing superturing about weather either, yet even the strongest computers can't predict it.
23:04:04 <lament> (nor humans)
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:42 <ehird`> ask in #ruby-lang
23:05:46 <liber> Ctrl + D kills it
23:05:51 <ehird`> no it >doesn't<
23:05:55 <ehird`> your program may make it that way
23:06:11 <liber> oops
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:08:43 <liber> thx oerjan.
23:20:14 <Figs> [][][][][][][][][][][][][][][][][][][][][][][]
23:20:33 <pikhq> == ""
23:21:31 <lament> in tcl no doubt?
23:21:39 <pikhq> No.
23:21:51 <pikhq> Well, after substitution, it does. . .
23:23:08 * Figs prods oklopok
23:24:43 <Figs> haha C-- compiler
23:24:45 <oerjan> it may be wise to use his actual nick
23:24:55 <Figs> oklopol*
23:25:09 <lament> why just prod?
23:25:20 * lament hands Figs an AK-47
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:34 <Figs> >.<
23:26:53 <Figs> and wrote pok :P
23:27:27 <Figs> could be worse, I could have called him Oktokop
23:27:47 <oerjan> Oklopus?
23:28:06 <Figs> or that
23:28:22 <Figs> I'll keep in mind to try to reduce typoes
23:28:23 <Figs> :P
23:28:39 <lament> in big-O notation: OklOpOl
23:28:48 <Figs> -.-
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:29:50 <Figs> :P
23:30:34 -!- Figs has changed nick to [x|x.
23:30:44 <[x|x> S:
23:30:49 -!- [x|x has changed nick to Figs.
23:31:11 <oerjan> quantum Figs?
23:31:17 <Figs> no
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:11 <bra|ket> heh
23:33:37 <oerjan> too bad my client doesn't use an initial <
23:33:58 <bra|ket> well, get a real client
23:34:11 <oerjan> o_O
23:38:43 <Figs> OH
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:40:28 <bra|ket> beautiful
23:40:59 <Figs> what is?
23:41:09 <bra|ket> life
23:41:16 <Figs> good? :)
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:49 <SimonRC> also:
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:46:32 <SimonRC> one of the originals
23:47:07 <SimonRC> "In California you can always find a party, but in Soviet Russia the Party can always find YOU!"
23:47:17 <SimonRC> oops, missing colon
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:53 <Figs> aww :P
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.