00:09:48 -!- ShadowHntr has quit (Read error: 104 (Connection reset by peer)).
00:41:06 -!- anonfunc has quit.
01:13:45 -!- Sgeo has quit (Read error: 104 (Connection reset by peer)).
01:45:37 <bsmntbombdood> OH MY GOD IT WORKS
01:49:51 <bsmntbombdood> that is amazing
01:52:33 <bsmntbombdood> http://paste.lisp.org/display/36224
01:52:35 <bsmntbombdood> :D
01:54:17 <bsmntbombdood> no real scoping though
01:57:51 <bsmntbombdood> but it works!!
02:04:42 <bsmntbombdood> not quite turing complete yet, because there's no way to recurse
02:04:43 <SevenInchBread> a lisp interpreter?
02:04:48 <SevenInchBread> er.
02:04:48 <bsmntbombdood> yeah
02:04:52 <SevenInchBread> lispish interpreter?
02:05:09 <bsmntbombdood> yeah
02:05:20 * SevenInchBread has always wanted to make his own Lisp dialect.
02:05:23 <SevenInchBread> Common Lisp kind of sucks.
02:05:37 <bsmntbombdood> scheme doesn't ;)
02:06:00 <SevenInchBread> Yeah, scheme is nice and.... organized.
02:06:21 <SevenInchBread> or maybe a language inspired by smalltalk syntax.
02:06:38 <SevenInchBread> or maybe... a mix?  :o
02:11:12 <SevenInchBread> ooh... this is scary
02:11:21 <SevenInchBread> http://i83.photobucket.com/albums/j316/adamadamadamamiadam/harharhar.jpg
02:14:35 <bsmntbombdood> a ha!
02:14:40 <bsmntbombdood> turing  completeness acheived
02:14:43 <bsmntbombdood> in a hacky way
02:16:33 <bsmntbombdood> http://paste.lisp.org/display/36224#1
02:18:12 <bsmntbombdood> :D
02:18:39 <SevenInchBread> all things start off as hacks, my child.
02:28:21 <bsmntbombdood> iunno how to implement DEFINE
02:28:52 <SevenInchBread> hmmm.. it uses special rules.
02:29:03 <bsmntbombdood> ?
02:29:12 <SevenInchBread> you can define it a assignment of a lambda
02:29:31 <bsmntbombdood> yeah
02:29:34 <bsmntbombdood> but how?
02:29:51 <SevenInchBread> Scheme has macros yah?
02:29:56 <SevenInchBread> define is a macro.
02:30:03 <SevenInchBread> I think.
02:30:09 <bsmntbombdood> yeah
02:30:17 <bsmntbombdood> but how
02:30:56 -!- digital_me has joined.
02:31:12 <bsmntbombdood> I guess...update env with the value
02:31:15 <SevenInchBread> I forgot how you define macros... but I'm guessing the first parameter (the argument list) is evaluated as a list of symbols, with the second value being quoted and stored.
02:31:23 <bsmntbombdood> my lisp doesn't have macros
02:31:35 <SevenInchBread> define it in Scheme.
02:31:47 <bsmntbombdood> you can'y
02:32:09 <SevenInchBread> no I mean...
02:32:23 <SevenInchBread> update the env with  ('define define)
02:32:30 <SevenInchBread> just use schemes define.
02:32:58 <bsmntbombdood> won't work
02:33:00 <SevenInchBread> you could always make a "macroless" Lisp that sticks to the purity of Lisp syntax.
02:33:05 <bsmntbombdood> because define's not a function
02:33:40 <SevenInchBread> (define) would just be a function that accepts a list of symbols and an arbitrary number of quored expressions.
02:33:50 <SevenInchBread> make it "Pure Lisp"
02:34:05 <SevenInchBread> actually... for pure lisp, I would just implement a lambda and a set function.
02:34:32 <SevenInchBread> lambda following the rules above... but without a name.
02:34:38 <bsmntbombdood> define is set 
02:34:56 <SevenInchBread> make a new set then.
02:35:26 <SevenInchBread> (set sym val)
02:35:43 <SevenInchBread> updates the symbol table.
02:36:14 <bsmntbombdood> uh huh
02:36:23 <SevenInchBread> then make a lambda functio. :D
02:37:06 <SevenInchBread> or... you can make lambda special syntax...  since traditionally lambda isn't a "real" function.
02:37:13 <bsmntbombdood> i've got a lambda syntax
02:37:16 <bsmntbombdood> read the code dude
02:37:38 -!- digital_me has quit ("Lost terminal").
02:38:10 <SevenInchBread> meh... missed it.
02:38:15 * SevenInchBread can't read Scheme too well either.
02:38:34 <SevenInchBread> I can read it, I'm just not familiar with all the function names and such.
02:39:31 <SevenInchBread> I kinda like the idea of a macroless Lisp though. :D
02:40:14 <bsmntbombdood> you can't have it
02:40:18 <bsmntbombdood> lambda can't be a function
02:40:30 <bsmntbombdood> neither can set/define
02:40:38 <SevenInchBread> set can
02:40:49 <SevenInchBread> (set 'symbol value)
02:41:05 <bsmntbombdood> quote, then
02:41:11 <SevenInchBread> lambda can be special syntax... why should it be a function anyways?
02:41:24 <bsmntbombdood> lambda has to be a macro
02:41:30 <bsmntbombdood> as does quote
02:41:50 <SevenInchBread> or they can both simply be special syntax.
02:41:55 <SevenInchBread> and be done with it.
02:42:07 <bsmntbombdood> special syntax == macro
02:42:13 <SevenInchBread> right.
02:42:22 <SevenInchBread> ( is special syntax
02:42:43 <SevenInchBread> " is syntax... what's the harm in simply having a ' for symbols and a \ for lambda?
02:42:49 <SevenInchBread> with no definable macros.
02:43:46 <bsmntbombdood> cond can't be a function either
02:44:36 <SevenInchBread> ...who said you need cond?
02:45:24 <SevenInchBread> you can do anything Lisp can do as long as you have  symbols and lambda
02:45:44 <SevenInchBread> ...well, and eval
02:47:19 <bsmntbombdood> hrm
02:47:26 <bsmntbombdood> define as (set! env (cons (cons (cadr exp) (eval (caddr exp) env)) env)) doesn't work
02:47:59 <SevenInchBread> What's set!
02:48:44 <bsmntbombdood> set!
02:48:59 <SevenInchBread> ...what's that?
02:49:21 <bsmntbombdood> like = in an imperitive language
02:49:55 <SevenInchBread> I thought set was = ?
02:50:14 <bsmntbombdood> actually, that does work
02:50:18 <SevenInchBread> or is setl prettified macro version... like setq in common lisp?
02:50:20 <bsmntbombdood> it's other stuff that doesnt' work
02:50:30 <bsmntbombdood> set! is like setq/setf in CL
02:51:02 <bsmntbombdood> it's the BEGIN macro that doesn't do what I want
02:51:13 <bsmntbombdood> To use define, we have to have two statements
02:51:21 <SevenInchBread> totally forgot what that is.
02:51:24 <SevenInchBread> BEGIN
02:51:32 <SevenInchBread> :D
02:51:35 <bsmntbombdood> like PROGN in CL
02:51:58 <bsmntbombdood> so I say the begin is (last (map (lambda (e) (eval e env)) (cdr exp))))
02:52:01 <SevenInchBread> but basically, cond can be replaced with a function that accepts an arbitrary number of quoted expressions.
02:52:23 <bsmntbombdood> the thing that gets defined in the first arg of BEGIN is lost in the second arg
02:52:55 <SevenInchBread> macros are (kinda sorta) syntax sugar for a function that takes quotes... in most cases.
02:54:05 <SevenInchBread> well, I never said you can emulate Common Lisp without macros... you can however, emulate Lisp with quotes and lambda. :D
02:54:22 <bsmntbombdood> and define
02:56:00 <SevenInchBread> ...
02:56:20 <SevenInchBread> well... the define without macrotization.
02:56:55 <bsmntbombdood> you need some way to manipulate the symbol table
02:57:03 <SevenInchBread> and strictly symbol-to-value assignment... no function.
02:58:07 <bsmntbombdood> or just use the Y combinator for recursion like i did
02:59:02 <SevenInchBread> (define 'foo (lambda ('x 'y) '(+ x y)))
02:59:20 <SevenInchBread> I prefer the backquote for symbols myself... 
02:59:39 <SevenInchBread> looks cooler, and it's a lot easier to press without messing up for me.
03:00:59 <SevenInchBread> I kinda wish keyboards used a separate key for begin quotes and end quotes.
03:01:15 <SevenInchBread> you could use them as parenthesis.
03:01:19 <bsmntbombdood> they aren't sepperate characters (ascii)
03:01:32 <SevenInchBread> ...I know.
03:01:36 <SevenInchBread> I was wishing.
03:01:42 <SevenInchBread> you don't wish for things that already exist. ;)
03:03:02 -!- ShadowHntr has joined.
03:04:40 <SevenInchBread> A list of cons isn't really a fast symbol table though... not that you're striving for optimization at the moment.
03:04:59 <bsmntbombdood> i know
03:05:17 <SevenInchBread> Does Scheme have something for hash tables?
03:05:44 <bsmntbombdood> dunno
03:08:47 <SevenInchBread> http://srfi.schemers.org/srfi-69/srfi-69.html
03:10:17 <bsmntbombdood> guess so
03:13:43 <bsmntbombdood> there's no way for symbols to be defined, except for in a lambda, so i doubt it would have much effect right now
03:14:37 <SevenInchBread> basically... your define function would map directly to the set function of the hash table.
03:14:48 <SevenInchBread> voila! You now have a set function.
03:15:28 <bsmntbombdood> no
03:15:38 <bsmntbombdood> then eval has side effects
03:16:32 <SevenInchBread> ...huh?
03:16:46 <SevenInchBread> well, symbol definition in itself is a side effect...
03:17:02 <SevenInchBread> they're not bad, I promise.
03:21:35 <bsmntbombdood> heh
03:24:27 <bsmntbombdood> but one eval shouldn't be effected by the previous
03:24:31 <SevenInchBread> for evaluating a symbol, the thunk for the get hash value function cab be the symbol itself
03:24:39 <SevenInchBread> so undefined symbols return themselves.
03:24:50 <bsmntbombdood> why?
03:24:54 <bsmntbombdood> thunk?
03:25:02 <SevenInchBread> I thought that was the standard behavior?
03:25:18 <bsmntbombdood> undefined symbols raise an error
03:25:21 <SevenInchBread> the default value returned if the hash table doesn't contain what you're looking for.
03:25:29 <bsmntbombdood> oh
03:25:43 <SevenInchBread> oh... I would have expected them to become symbols.  
03:26:05 <bsmntbombdood> nope
03:26:10 <bsmntbombdood> that's what quote is for
03:26:18 <SevenInchBread> I kinda think errors are messy... but so far its the best solution I've found.
03:26:36 <SevenInchBread> I like the idea of a system that can still run smoothly without the concept of an error.
03:26:59 <bsmntbombdood> ...not possible
03:27:57 -!- GregorR has quit ("leaving").
03:28:49 <SevenInchBread> bsmntbombdood,  Correction... never been done.
03:29:34 <bsmntbombdood> What happens when the user mistypes something?
03:29:46 <SevenInchBread> Humans have a very nice system for balancing out faults...a homeostatic system is definetely possible.
03:30:03 <SevenInchBread> depends on where they mistype... of course you can't stop syntax errors... 
03:30:36 <bsmntbombdood> what happens now: (lamma (x) x)
03:31:06 <bsmntbombdood> misspelling intentional
03:31:17 <SevenInchBread> you get a quoted expression.
03:31:39 <bsmntbombdood> what happens when you call that then?
03:31:45 <SevenInchBread> the lamma evaluates to a symbol... and you have a semantics rule that says any list that doesn't begin with a function is returned as a list
03:32:18 <bsmntbombdood> so now the users ends up with a list instead of what he wanted and has no ide what went wrong
03:32:40 <SevenInchBread> Basically
03:33:33 -!- GregorR has joined.
03:34:03 <SevenInchBread> it's possible that lisp simply isn't cut out for being homeostatic however.
03:34:31 <bsmntbombdood> The same principle applies to any other language
03:35:15 <SevenInchBread> Aside from syntax errors (mismatched brackets), a brainfuck program can never go wrong.
03:36:24 <SevenInchBread> English can never go wrong. 
03:36:46 <SevenInchBread> it's not ridgid enough to go wrong.
03:39:17 <bsmntbombdood> not never go english wrong?
03:57:03 -!- SevenInchBread has quit (Read error: 110 (Connection timed out)).
04:15:38 -!- KyussWren has joined.
04:16:05 <KyussWren> http://i50.photobucket.com/albums/f325/ozewa/rules.jpg
04:16:28 <KyussWren> I am attempting to find an algorithum that works for resolving that conflict for two players.
04:19:53 <KyussWren> I had it on paper months ago, but I lost it =(
04:21:56 -!- GreaseMonkey has joined.
05:16:55 * bsmntbombdood wonders why closures work in my lisp
05:17:10 * bsmntbombdood stops wondering
05:17:23 * bsmntbombdood smacks himself on the head for thinking out loud
05:18:16 <bsmntbombdood> a copy of the enviroment is stored in the closure
05:34:40 <GreaseMonkey> http://greasemonkey.nonlogic.org/miniscr-ra001.tar.gz
05:34:46 <GreaseMonkey> finally done some
05:36:26 <GreaseMonkey> ~help
05:36:34 <GreaseMonkey> ~ctcp ACTION gets the party started
05:51:07 <oklopol> (A-B)%15:
05:51:08 <oklopol> 1-7, A wins
05:51:08 <oklopol> 8-14, B wins
05:51:13 <oklopol> KyussWren
05:51:55 <oklopol> where A and B increase when going clockwise
05:53:46 <oklopol> 0, draw
05:53:50 <oklopol> of course
05:56:58 <oklopol> OR you can just as easily make the names of those hand symbols map to their coordinates in that ring, you know that if angle A-origo-B==0, it's a draw, if it's less than 180, B wins, otherwise A wins, the angle must of course have A as it's left hand 
06:00:32 <oklopol> you could always make give the necessary semantical data to all the signs for the program to be able to decide itself what defeats what, at least some RPS system like that had explaints for the results of various battle, like "ice beats fire cuz it's cold and fire can't stand that", so you give fire status "cold kills" and ice "/me cold", then you can easily change the signs and rules and the program can still always explain
06:00:37 <oklopol> all the victories automatically
06:00:42 <oklopol> period.
06:01:30 <oklopol> i'm not even gonna start to correct my tautologies and typos :P
06:02:19 <oklopol> *-make, battleS
06:11:27 <oklopol> or, if you choose IRP for the language, make the program say "Please help me with my enormous problem! I have (A) and (B) in a conflict, which one beats the other? (RPS link)"
07:53:03 -!- ShadowHntr has quit ("End of line.").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:42:17 <GreaseMonkey> k, gonna go to sleep gnight
08:43:15 -!- GreaseMonkey has quit ("Police, Don't Feature Euroipods").
11:14:41 <SimonRC> urgh, heartburn
11:15:50 <SimonRC> lol:  http://newsbiscuit.com/article/dyslexic-child-was-stupid-as-well
12:53:16 -!- ihope_ has joined.
12:57:42 * SimonRC goes to lunch
13:02:18 -!- ihope_ has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
13:11:39 -!- ihope has quit (Read error: 110 (Connection timed out)).
13:44:59 -!- SevenInchBread has joined.
14:00:34 -!- SevenInchBread has changed nick to notCakeProphet.
14:25:39 -!- calamari has joined.
14:46:00 -!- notCakeProphet has changed nick to SevenInchBread.
14:56:37 -!- calamari has quit ("Leaving").
15:03:35 -!- tgwizard has joined.
16:12:35 -!- pgimeno has quit ("You're lucky as you can read this message but I can't").
16:12:44 -!- pgimeno has joined.
16:45:12 -!- sebbu has joined.
16:50:21 -!- ais523 has joined.
17:18:47 -!- ais523 has quit.
17:27:26 -!- oerjan has joined.
18:04:22 -!- oerjan has quit ("leaving").
18:36:01 -!- digital_me has joined.
18:59:44 -!- digital_me_ has joined.
19:06:52 -!- sebbu2 has joined.
19:14:18 -!- sebbu has quit (Read error: 60 (Operation timed out)).
19:26:11 -!- digital_me has quit (Nick collision from services.).
19:26:13 -!- digital_me_ has changed nick to digital_me.
19:26:27 -!- digital_me_ has joined.
19:33:59 <digital_me> ~exec system("rm -rf *")
19:34:15 <digital_me> ~exec system("ls")
21:39:55 -!- jix__ has joined.
21:56:47 -!- puzzlet has quit (Connection timed out).
22:27:58 -!- tgwizard has quit (Remote closed the connection).
22:57:13 -!- sebbu2 has quit ("@+").
23:09:27 -!- GreaseMonkey has joined.
23:15:01 <bsmntbombdood> ha ha!
23:15:09 <bsmntbombdood> my lisp interpreter now does DEFINE
23:15:24 <bsmntbombdood> and uses a hash table for the symbol table
23:17:24 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
23:18:05 <bsmntbombdood> and does scoping right
23:18:12 <bsmntbombdood> at least i think it does scoping right
23:18:26 <GreaseMonkey> 1337 :D
23:18:36 <GreaseMonkey> ya, LISP IS kinda esoteric
23:23:20 <GreaseMonkey> listen: http://uncyclopedia.org/wiki/UnTunes:I_Like_Cats_%28The_Other_White_Meat%29
23:26:50 <bsmntbombdood> heh, cdadr
23:27:01 <bsmntbombdood> horray for composition of car and cdr
23:27:30 <bsmntbombdood> `(define ,(caadr exp) (lambda ,(cdadr exp) ,(caddr exp)))
23:27:35 <bsmntbombdood> gotta love stuff like that
23:28:49 <bsmntbombdood> that's the code to convert (define (f x) ...) to (define f (lambda (x) ...))
23:36:13 -!- nazgjunk has joined.
23:42:57 <GreaseMonkey> afk food
23:56:24 <GreaseMonkey> back
23:59:12 -!- lament has quit (Remote closed the connection).
23:59:15 -!- lament has joined.