00:00:15 <ihope> If you do all the setup right, maybe you can have the loop iterate Many, Many Times...
00:00:35 <int-e> not if it's just a single loop - that's the point.
00:00:58 <int-e> if there are two loops on the other hand ...
00:01:10 <int-e> I'm not sure yet what you can do with that
00:02:06 <ihope> You can do a bunch!
00:07:37 <ihope> Well, we obviously can't fit two useful loops into 6 spots.
00:08:41 <ihope> We need at least 2 .'s, an @, something to set the top bit to zero, and the brackets.
00:08:44 <int-e> [[<]?] or [?[<]] :)
00:09:32 <ihope> ...So we have @[loopguts]?
00:09:49 <int-e> hmm. that's pointless
00:10:06 <int-e> you can omit the outer [] then
00:11:10 <int-e> ok, so we need at least 2 characters before the loop, two for the outer loop, three for the inner loop and two dots.
00:11:45 <int-e> actually, we need one more for the outer loop to make sense - [[...]] is equivalent to [].
00:12:04 <int-e> that makes a minimum of 8 for two loops.
00:12:39 <int-e> for one loop, I have a lower bound of 13 characters now, and the above example with 14.
00:13:58 <ihope> Wait, you mean that one loop needs to have at least 13 characters to be of any use?
00:14:39 <int-e> no. that was the total program length if the program contains only one loop.
00:16:27 <ihope> So [1..12] maps onto [1..12]?
00:16:30 <int-e> in fact it should be possible to prove that this program structure, @<<<<@[....>@], is the best possible.
00:16:43 <int-e> for a single loop program.
00:17:38 <int-e> ihope: I'm not 100% sure. I'm sure that 1 to 7 map to 1 to 7.
00:23:21 <int-e> At least PDA-BF kann model every PDA.
00:24:59 <SimonRC> Well, BF-PDA has two symbols but can have many states. I will have to ask my TC lecturer.
00:25:52 <int-e> if you encode bits as 10 and 01 on the stack, you can test a bit using [>> code for 1 <<]>[> code for 0 >]>
00:26:15 <int-e> previous to last > -> <
00:27:01 <int-e> if you number the states in binary and keep the current state on the top of the stack you can decode it, modify the stack and push a new state onto it.
00:27:36 <int-e> You can then use the topmost bit to allow the program to terminate.
00:30:39 <ihope> New version of the language is up.
00:31:12 <EgoBot> help ps kill i eof flush show ls
00:31:13 <EgoBot> 1l 2l adjust axo befunge bch bf{8,[16],32,64} glass glypho kipple lazyk malbolge pbrain rail sadol sceql udage01 unlambda
00:32:38 <ihope> !unlambda ```````````````.T.h.i.s. .i.s. .a. .t.e.s.t..i
00:33:43 <GregorR> Up to 18 languages, only 2 more to hit 20 :)
00:34:08 <int-e> !unlambda `.i````ss``s`k`s.i``s`k`ki|``s``s|.```s``s|..``s``s|.i``s``s|.```s``s|.```s``s|.```s``s|.```s``s|.s``s``s|.s``s``s|.```s``s|.```s``s|.s``s``s|.```s``s|.k``s``s|.```s``s|.s``s``s|..``s``s|.i``s``s|.```s``s|.```s``s|.s``s``s|.```s``s|.k``s``s|.```s``s|.k``s``s|.i``s``s|.|i``s``s|.```s``s|.```s``s|.s``s``s|.```s``s|.```s``s|.s``s``s|.|``s``s|..i
00:34:11 <EgoBot> `.i````ss``s`k`s.i``s`k`ki|``s``s|.```s``s|..``s``s|.i``s``s|.```s``s|.```s``s|.```s``s|.```s``s|.s``s``s|.s``s``s|.```s``s|.```s``s|.s``s``s|.```s``s|.k``s``s|.```s``s|.s``s``s|..``s``s|.i``s``s|.```s``s|.```s``s|.s``s``s|.```s``s|.k``s``s|.```s``s|.k``s``s|.i``s``s|.|i``s``s|.```s``s|.```s``s|.s``s``s|.```s``s|.```s``s|.s``s``s|.|``s``s|..i
00:34:18 <GregorR> Step one: write interpreter. Step two: Add interpreter to EgoBot :P
00:35:43 <GregorR> Incidentally, is BDSM the interpreter named purposely after BDSM the sexual fetish?
00:36:35 <int-e> ihope: if I make that number big, that acts like a tape, right? i.e. infinity:<brainfuck code> would behave like a normal brainfuck program (if allowed)?
00:36:58 <ihope> int-e: yes, except you can't use infinity :-)
00:37:59 <SimonRC> int-e: if you're going to run programs like that, can you use pastebin or just /msg please
00:38:52 <int-e> SimonRC: it was a one time demonstration of a quine. I wasn't going to repeat it.
00:39:19 <SimonRC> That's damn short for a BF quine.
00:40:29 <SimonRC> ihope: that one's been done
00:40:38 <SimonRC> I was an IOCCC entry one year
00:41:04 <ihope> Note to self: look things up BEFORE asking.
00:41:50 <int-e> ihope: nnn:@[>>[>]@[<]<]>[>.] ... this or something similar like that should print nnn digits :)
00:42:55 * SimonRC humms the _Terminator_ theme.
00:43:27 <SimonRC> dadadaaaaah daadaadaaaaah dadadaaaadadadaadaaah.
00:43:44 * ihope doesn't know that one, so he hums Mission Impossible
00:43:46 * SimonRC feels inspired to create a new Esolang.
00:43:50 <int-e> nnn:@[>>[>]<[@<.]<] should print something like 2^nnn*nnn digits.
00:44:29 <int-e> err, no, 2^nnn. the nnn factor is wrong.
00:44:39 <ihope> How about printing a number equal to Graham's number, but doing nnn iterations instead of 64?
00:46:04 <SimonRC> ihope: It could be isomorphic to BF, da > dah < daa + daah - daaa [ daaah ] daaaa . daaaah ,
00:46:27 <SimonRC> whitespace would be ignored
00:47:04 <ihope> Would "daaaaah" be something like [-]+[]?
00:51:30 <SimonRC> more like: daaadaah daaahdaa daaadaaah
00:51:53 <EgoBot> help ps kill i eof flush show ls bf_txtgen
00:51:55 <EgoBot> 1l 2l adjust axo befunge bch bf{8,[16],32,64} glass glypho kipple lazyk malbolge pbrain rail sadol sceql udage01 unlambda
00:52:47 <GregorR> lament: Give me an interpreter that isn't awful ^_^
00:53:00 <lament> oh, add lambda calculus.
00:53:28 <lament> except i'm not sure if it's a good idea to add pure LC
00:53:41 <lament> where as output you just get a LC expression
00:54:02 <lament> so it would have to be LC with some sort of output (and perhaps even input)
00:54:32 <int-e> ihope: making the nnn a variable is an interesting problem
00:54:38 <lament> I want a LC interpreter that people could extend with definitions
00:54:48 <ihope> int-e: what do you mean?
00:54:53 <EgoBot> 116 ++++++++++++++[>+++++>+++++++>+++>++++++<<<<-]>++.>+++.+++++++..+++.>++.------------.>+++.<<.+++.------.--------.>+. [829]
00:54:58 <GregorR> Like how my Glass interpreter works.
00:55:08 <lament> or how falsebot worked
00:55:09 <GregorR> !bf ++++++++++++++[>+++++>+++++++>+++>++++++<<<<-]>++.>+++.+++++++..+++.>++.------------.>+++.<<.+++.------.--------.>+.
00:55:31 <GregorR> The interpreters are the most fun when they're user-expandable.
00:55:32 <lament> I can write such an interpreter (in about ten minutes) but it will be slow
00:55:37 <int-e> ihope: for every value of nnn you have a PDA. But by increasing nnn you can increase the PDAs state space - so the problem becomes what PDAs you can encode in that space ...
00:56:00 <lament> GregorR: EgoBot executes the program anew each time?
00:56:13 <GregorR> lament: So it would need some method of caching to file.
01:02:06 <ihope> Say, did you find those extra lives you had?
01:02:13 <ihope> Probably, seeing as how you
01:02:22 <ihope> 're not [dead] anymore.
01:02:44 <GregorR> I'll have to find a green mushroom somewhere and eat it. It'll either be moldy and then I'll have zero left, or it'll be magic and I'll have two again.
01:03:03 <ihope> What are the chances of it being moldy?
01:03:16 <GregorR> Depends on where I find it :P
01:03:38 <ihope> Don't the best ones grow at the bottom of the Valley Gorge?
01:03:58 <ihope> SimonRC: it turns text into BF code which outputs it?
01:04:03 <GregorR> ihope: No, they're in boxes with big question marks on them.
01:04:39 <SimonRC> I meant how does it create the program?
01:04:47 <GregorR> SimonRC: http://lilly.csoft.net/~jeffryj/programs/bf/textgen.java
01:06:11 <ihope> ...Anyway, that gave me a nice long error message.
01:06:41 <SimonRC> that looks rather alarming
01:07:17 <ihope> !malbolge_txtgen Hello, world!
01:07:33 <GregorR> You want to write malbolge_txtgen? I'll include it if you do :P
01:08:01 <SimonRC> IIRC, there is one that was used to create a Malbolge hello world program
01:08:28 <ihope> Did that actually output "Hello, world!"?
01:08:32 <GregorR> But its selection function was very liberal.
01:08:41 <EgoBot> java.lang.IllegalArgumentException: n must be positive
01:08:57 <SimonRC> Ah, wait, no, it creates the BF programs by Intelligent Design, not evolution.
01:09:19 <GregorR> No, it creates the BF programs by Divine Creation.
01:09:32 <ihope> It creates them by Creation.
01:11:03 <ihope> Well, I can't imagine it'd be too hard to write a "Hello, world!" program in Malbolge.
01:11:29 <ihope> First, you execute j about three times.
01:11:45 <ihope> This should put the data pointer in a random memory location, more-or-less.
01:12:16 <SimonRC> Actually, there is a 99 bottles of beer program in Malbolge.
01:12:39 <ihope> Then you do all the appropriate "stuff", and bang!
01:12:40 <SimonRC> It consists of a load or crap that outputs a gzipped text of the song.
01:13:14 <SimonRC> ihope: it gets much shorter when gzipped
01:14:27 <ihope> SimonRC: but not shorter than "Hello, world!", I'm sure...
01:14:57 <GregorR> I still refuse to believe in said 99bob in Malbolge.
01:16:01 <SimonRC> GregorR: It only has to output 807 bytes, rather than 11785
01:16:49 <GregorR> It doesn't say anything about gzipping.
01:17:02 <GregorR> !malbolge http://www.99-bottles-of-beer.net/download/995?PHPSESSID=db289c2cadd3cce36d2f1ee62e193ebe
01:17:07 <EgoBot> invalid character in source file
01:17:43 <GregorR> I can't get it to tell me anything but that :P
01:17:51 <GregorR> lament: Your interp not going so well? :P
01:19:09 <SimonRC> GregorR: IIRC, it might be the one that cheats by using chars > 127
01:20:32 <int-e> ihope: calculating Graham's number to nnn steps is not possible that way.
01:21:16 <int-e> ihope: (in PDA-BF version 2)
01:23:37 <EgoBot> invalid character in source file
01:23:51 <lament> and now my brother came and is playing the drumset downstairs
01:23:52 <EgoBot> 99 bottles of beer on the wall,
01:24:05 <lament> so it's pretty much impossible to think
01:24:24 <GregorR> 17:23:52 <EgoBot> Take one down, pass it around,
01:24:24 <GregorR> 17:23:54 <EgoBot> Process 1 killed.
01:24:33 <int-e> ihope: OTOH I believe (2^(nnn/2))! is doable. (also (2^(nnn*(1-epsilon)) for all epsilon)
01:24:40 <GregorR> Exciting conclusion too :P
01:25:01 -!- ihope_ has joined.
01:25:56 <int-e> [2^(nnn*(1-epsilon))]! ... there.
01:34:14 -!- ihope has quit (Nick collision from services.).
01:34:21 -!- ihope_ has changed nick to ihope.
01:35:09 <lament> GregorR: you're there?
01:35:19 <lament> i have something working now
01:44:03 -!- int-e has quit ("Bye!").
01:50:13 <lament> my interpreter is cool :)
01:51:11 <lament> an annoying side-effect of coolness
01:52:08 <lament> and i want to kill my brother
02:03:41 <ihope> What's the shortest TLD?
02:05:53 <lament> i don't think there're any one-character ones
02:07:11 -!- ihope has quit ("Chatzilla 0.9.69.1 [Firefox 1.5/2005111116]").
02:20:40 -!- GregorR-L has joined.
02:21:19 <GregorR-L> lament: Will you still be here in two hours?
02:24:26 <GregorR-L> I suspect not, since you're not here now ^_^
02:26:04 <lament> but my interpreter doesn't work
02:26:27 <GregorR-L> OK, so the alternative question is, will it work in 2 hours? :P
02:26:49 <lament> that remains to be seen :|
02:27:05 <GregorR-L> Well, I'll be back home in two hours.
02:40:07 <lament> lua:~/python/lambda_eso lament$ python lambda.py
02:40:39 <lament> "*" is evaluated to the identity function with the side effect of printing *
02:44:05 <GregorR-L> Cool - upload it somewhere, I'll convert it to a /real/ programming language like C++, and then I'll add it to EgoBot.
02:44:24 <lament> what do you mean convert to a real programming language
02:44:27 <GregorR-L> I'm being sarcastic about the C++ part to harass you ;)
02:44:49 <lament> one sec, i'll add a function to show expressions
02:49:01 <lament> lua:~/python/lambda_eso lament$ python lambda.py
02:49:01 <lament> #show (plus two two "*" i)
02:49:02 <lament> \m.(\n.(\f.(\x.(m f n f x)))) \f.(\x.(f f x)) \f.(\x.(f f x)) "*" \x.x
02:49:47 <lament> (it's lazyish so (plus two two "*" i) doesn't get evaluated when it's being shown)
02:50:07 <lament> (but name substitution is actually performed during parsing)
02:52:06 <lament> that didn't quite work right
02:52:27 <lament> lua:~/python/lambda_eso lament$ python lambda.py
02:52:27 <lament> #show (plus two two " *" i)
02:52:28 <lament> \m.(\n.(\f.(\x.(m f n f x)))) \f.(\x.(f f x)) \f.(\x.(f f x)) " *" \x.x * * * *
02:52:48 <lament> first the expression is shown, then it still gets evaluated as normal, printing * * * *
02:55:53 <GregorR-L> Not knowing the language, I'll just smile and nod...
02:56:28 <lament> you don't know lambda calculus!
03:00:21 <lament> would be nice to have a way to show something evaluated
03:00:28 <lament> i wonder how to do that
03:01:15 <lament> perhaps #show should just always evaluate its argument immediately
03:01:59 <lament> #show (plus two two " *" i)
03:02:09 <lament> not very satisfactory, either :)
03:19:05 <GregorR-L> This class (or at least, the first few days) is dull.
03:37:47 <GregorR-L> Could you toss that on a URL somewhere?
03:40:28 <GregorR-L> Good - then I can just grab it and install it when I get home.
03:40:38 <GregorR-L> Then I'll probably update the egobot in the files archive ...
03:49:42 -!- GregorR-L has quit.
04:15:36 -!- CXI has quit (Connection timed out).
04:37:24 <GregorR> I note that you haven't tossed it on a URL somewhere :P
04:39:46 <lament> http://z3.ca/~lament/lambda_eso.zip
04:43:05 <GregorR> It would be nice if it were under some license >_>
04:44:16 <lament> as the matter of fact, i was planning to sue you tomorrow for using it without permission.
04:45:48 <GregorR> But it would still be nice if it was under a license.
04:45:52 <GregorR> Or if I had written permission :P
04:46:36 <EgoBot> help ps kill i eof flush show ls bf_txtgen
04:46:38 <EgoBot> 1l 2l adjust axo befunge bch bf{8,[16],32,64} glass glypho kipple lambda lazyk malbolge pbrain rail sadol sceql udage01 unlambda
04:46:50 <EgoBot> []Traceback (most recent call last):
04:47:32 <lament> ha, that's the only thing i don't check for exceptions on
04:47:36 <lament> naturally it's what broke :)
04:48:19 <GregorR> Hmm, don't think I needed to reload there :P
04:48:21 <EgoBot> [and c0 c1 c2 c256 c3 false i if iszero k not or plus pred s show succ true]
04:49:09 <lament> !lambda if (iszero (pred c1)) "zero" "not"
04:50:02 <lament> that's about the extent of my actual lambda calculus programming capabilities.
04:50:34 <EgoBot> \n.(n \x,x,y.y \x,y.x)
04:51:48 <lament> won't affect the actual running of programs
04:51:51 <GregorR> Well, only you can make it a bit fixed :P
04:52:00 <lament> \x,x,y is a rather strange list of arguments
04:52:34 <lament> anyway, to extend the definitions, you do something like
04:52:57 <lament> !lambda c4 = (succ c3);
04:53:27 <lament> c4 is the 4th church numeral.
04:54:05 <EgoBot> [and c0 c1 c2 c256 c3 c4 false i if iszero k not or plus pred s show succ true]
04:54:07 <lament> And now we need somebody who actually can program in lambda calculus to create some useful definitions.
04:55:55 <lament> !lambda y = \f.(\x.f(x x)) (\x.f(x x));
04:55:59 <EgoBot> Parser error: Unbound variable: x
04:56:22 <lament> !lambda y = \f.((\x.f(x x)) (\x.f(x x)));
04:56:25 <EgoBot> Parser error: Unbound variable: x
04:57:32 <lament> !lambda y = \f.((\x.(f(x x))) (\x.(f(x x))));
04:58:21 <GregorR> !glass {M[m(_o)O!"Glass is already extendable, and more fun :P"(_o)o.?]}
04:58:25 <EgoBot> Glass is already extendable, and more fun :P
04:58:47 <GregorR> !glass {M[m(_e)(Emote)!"agrees!"(_e)e.?]}
04:58:51 <EgoBot> <CTCP>ACTION agrees!<CTCP>
04:59:03 <lament> !lambda mult = \m,n,f.(n(m f));
04:59:24 * lament hopes the following is gonna work
05:01:15 <lament> !lambda fact = \f,x.((iszero x) 1 (mult x (f pred x))));
05:01:17 <EgoBot> Tokenizer error: Tokenizer can't comprehend '1'
05:01:24 <lament> !lambda fact = \f,x.((iszero x) c1 (mult x (f pred x))));
05:02:03 -!- Sgeo has quit.
05:03:37 <lament> woohoo i just made Python segfault
05:04:10 <GregorR> Glad it's only a subproc :P
05:16:06 <lament> the only thing worse than debugging Python is debugging Lambda Calculus.
05:16:30 <GregorR> Idonno, debugging Malbolge has to suck.
05:20:33 <lament> !lambda exp = \m,n.(n m);
05:20:59 <lament> some things are so pretty with church numerals
05:22:18 <GregorR> I have to take EgoBot down for a sec to update the archive (I need to clean the source, etc)
05:22:36 -!- EgoBot has quit ("*tinker tinker*").
05:28:17 <GregorR> I notice that every included interpreter that has a configure script was written by me :P
05:29:53 -!- EgoBot has joined.
05:33:27 <lament> !lambda fact = \f,x.((iszero x) c1 (mult x (f (pred x))));
05:34:02 <lament> !lambda y = \f.(\x.(f x x) \x.(f x x))
05:34:04 <EgoBot> Parser error: list index out of range
05:34:23 <lament> !lambda y = \f.(\x.(f x x) \x.(f x x));
05:34:31 <lament> i blame my brother and his drumset
05:34:43 <lament> (he stopped playing hours ago, but i think the effect is permanent)
05:34:48 <lament> !lambda fact = y fact;
05:35:06 <EgoBot> ************************************************************************************************************************************************************************************************************************************************************************************************************************************
05:35:49 <GregorR> Note that there's a maximum line length.
05:36:26 <EgoBot> ************************
05:37:04 <lament> i implemented some function
05:37:37 <lament> it's some mystery function
05:38:04 <lament> anybody care figure out what it is?
05:38:04 <GregorR> So now you have to take the results and figure out what it's doing :P
05:38:31 <lament> f(2) = 2, f(3) = 25, f(4) = 325
05:38:57 <lament> (unless 325 is the line limit)
05:40:08 <lament> works on my machine...
05:41:03 <GregorR> The BF interpreter in Glass works here, but not in EgoBot.
05:41:28 <lament> !lambda fact = \f,x.(\n.(n \x,x,y.y \x,y.x) x \f,x.(f x) \m,n,f.(n m f) x f \n,f,x.(n \g,h.(h g f) \u.x \u.u) x) ;
05:42:22 <lament> (i just copied the result of #show fact from my machine)
05:43:08 <lament> !lambda fact = \x.(\n.(n \x,x,y.y \x,y.x) x \f,x.(f x) \m,n,f.(n m f) x \x.(\f,x.(\n.(n \x,x,y.y \x,y.x) x \f,x.(f x) \m,n,f.(n m f) x f \n,f,x.(n \g,h.(h g f) \u.x \u.u) x) x x) \x.(\f,x.(\n.(n \x,x,y.y \x,y.x) x \f,x.(f x) \m,n,f.(n m f) x f \n,f,x.(n \g,h.(h g f) \u.x \u.u) x) x x) \n,f,x.(n \g,h.(h g f) \u.x \u.u) x)
05:43:12 <EgoBot> Parser error: list index out of range
05:43:27 <lament> !lambda fact = \x.(\n.(n \x,x,y.y \x,y.x) x \f,x.(f x) \m,n,f.(n m f) x \x.(\f,x.(\n.(n \x,x,y.y \x,y.x) x \f,x.(f x) \m,n,f.(n m f) x f \n,f,x.(n \g,h.(h g f) \u.x \u.u) x) x x) \x.(\f,x.(\n.(n \x,x,y.y \x,y.x) x \f,x.(f x) \m,n,f.(n m f) x f \n,f,x.(n \g,h.(h g f) \u.x \u.u) x) x x) \n,f,x.(n \g,h.(h g f) \u.x \u.u) x);
05:43:34 <lament> i will soon have to kick myself for flooding
05:44:04 <GregorR> Too bad four is a prime number :P
05:44:27 <GregorR> Oh, factorial, not factor :P
05:45:14 <GregorR> !glass {M[m(_s)S!(_o)O!<34>(_s)(ns).?"{M[m(_s)S!(_o)O!<34>(_s)(ns).?""1(_o)o.?2(_o)o.?
05:45:15 <GregorR> 1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}"1(_o)o.?2(_o)o.?1(_o)o.?2
05:45:15 <GregorR> (_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}
05:45:23 <GregorR> Sorry 'bout that flood >_>
05:49:49 <EgoBot> Tokenizer error: Tokenizer can't comprehend '4'
05:50:02 <EgoBot> ************************
05:51:42 <lament> !lambda c5 = succ c4; c6 = succ c5; c7 = succ c6; c8 = succ c7; c9 = succ c8; c10 = succ c9; fact c10 "*" i
05:53:56 <lament> although perhaps it will eat all your memory first.
05:55:16 <lament> !lambda c5 = succ c4; c6 = succ c5; c7 = succ c6; c8 = succ c7; c9 = succ c8; c10 = succ c9;
05:56:11 <lament> there're limitations to lambda calculus, even when the implementation is not written in python without any attempt to speed it up
06:19:14 -!- GregorR-L has joined.
06:19:29 <GregorR-L> Wow. When FlightGear crashes, it REALLY crashes.
06:19:40 <GregorR-L> Takes the whole f***ing system down with it.
06:20:40 <GregorR-L> Also, I really need to upgrade my 200gig hard disk to ext3 :P
06:25:32 <lament> GregorR-L: i'm torturing egobot
06:25:38 <lament> how do i kill processes?
06:26:00 <GregorR-L> It would have been doing fine if flightgear wasn't crashing.
06:26:06 <GregorR-L> I rebooted my system, GregorR and EgoBot are ghosts.
06:26:54 <GregorR-L> I should dig up my Appe Workgroup server and run EgoBot on that ^_^
06:38:12 -!- GregorR has quit (Read error: 110 (Connection timed out)).
06:40:41 -!- EgoBot has quit (Read error: 110 (Connection timed out)).
06:48:04 -!- GregorR has joined.
06:48:27 -!- GregorR-L has quit.
06:51:07 -!- EgoBot has joined.
07:14:47 <EgoBot> [and c0 c1 c2 c256 c3 c4 exp fact false fr i if iszero k mult not or plus pred s show succ true y]
07:15:27 <lament> !lambda c5 = succ c4; c6 = succ c5; c7 = succ c6; c8 = succ c7; c9 = succ c8; c10 = succ c9;
07:17:59 -!- nooga has joined.
07:19:06 <GregorR> lament made a Lambda Calculus interpreter with caching, which is now in EgoBot :)
07:22:56 <nooga> i don't even understand lambda claclulus :D
07:38:07 <nooga> but i think it's cool
07:48:46 * GregorR begins to write the Glee extension to Glass, which will allow you to access certain C functions.
07:50:14 <nooga> i've planned using ) function from SADOL to call functions from dlls
07:50:33 <nooga> so that we'll be albe to port i.e. SDL for SADOL :>
07:51:21 <GregorR> dlopen is one of the first things I'll get to work for Glee ^_^
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:13:59 <GregorR> Trying to generically call functions = no fun.
08:14:16 <GregorR> Maybe I can build a va_list ...
08:15:51 <GregorR> My interface to open, read, write and close worked, but open apparently didn't set the mode, so the file was mode 0000
08:24:25 <nooga> does egobot use fork() or some internal threading?
08:25:52 <GregorR> Because the interpreters are external.
08:25:56 <GregorR> It indeed uses fork and exec.
08:26:59 <GregorR> The code is available on the files archive if you're interested.
08:29:09 <GregorR> http://esoteric.voxelperfect.net/svn/esofiles/egobot/egobot-0.5.tar.bz2
09:01:57 <GregorR> Idonno, just wondering what "hm mhm cool" means :P
09:20:15 <GregorR> I've decided that it's impossible to write a generic interface to dlopen :(
09:55:31 -!- CXI has joined.
10:04:01 -!- lirth has quit ("you should feel more feel you should take more take").
12:35:23 <nooga> hm, where to get the list of functions which i can use in NPC script?
12:55:32 -!- nooga has quit ("Lost terminal").
14:30:33 -!- jix has joined.
14:45:51 -!- lirthy has joined.
18:59:47 -!- Keymaker has joined.
19:55:59 <GregorR> Oh, my sweet sweet Moxie, it's been too long.
19:56:28 <Keymaker> hey, gregorr, i got an idea for your esobot, perhaps you could add trigger in it?
19:57:10 <Keymaker> since you asked about language suggestions, was it yesterday.. ;)
20:02:15 <EgoBot> help ps kill i eof flush show ls bf_txtgen
20:02:17 <EgoBot> 1l 2l adjust axo befunge bch bf{8,[16],32,64} glass glypho kipple lambda lazyk malbolge pbrain rail sadol sceql trigger udage01 unlambda
20:02:21 <GregorR> That didn't come out as dramatic as I would have liked :P
20:02:30 <GregorR> I did !help too fast after !reload, so it didn't get it :P
20:03:05 <EgoBot> To use an interpreter: <interpreter> <program> Note: <program> can be the actual program, an http:// URL, or a file:// URL which refers to my pseudofilesystem.
20:04:39 <Keymaker> do i start it with "!trigger"?
20:04:54 <Keymaker> !trigger http://koti.mbnet.fi/yiap/trigger/hello.tri
20:05:17 <GregorR> And my network connection is sort of sucky right now, so http:// might or might not work >_<
20:05:36 <GregorR> !trigger HHHeeelll lllooo wwwooorrrlllddd!!!
20:05:40 <Keymaker> !trigger hhhiii gggrrreeegggooorrr
20:06:28 <Keymaker> i just invented small silly esolang
20:06:35 <Keymaker> gonna write the specs and interpreter later today
20:06:47 <GregorR> Write the interpreter in Glass! 8-D
20:07:09 <Keymaker> i couldn't sorry.. glass is too obscure for me
20:07:20 <Keymaker> i can't understand languages like that :)
20:07:29 <GregorR> !glass {M[m(_d)(Debug)!"BF""bf"(_d)(fc).?]}
20:07:33 <EgoBot> (_a)A!(_o)O!(_s)S!(_t)$(_p)1=,(_pp)<0>=(_pc)(_pp)*(_p)*(_s)l.?(_a)(le).?=/(_pc)(_pcur)(_p)*(_pp)*(_s)i.?(_s)(sn).?=(_isc)(_pcur)*<43>(_a)e.?=/(_isc)(_isc)<0>=(_c)(mp)*mg.?=(_c)(_c)*<1>(_a)a.?=(mp)*(_c)*ms.?\(_isc)(_pcur)*<45>(_a)e.?=/(_isc)(_isc)<0>=(_c)(mp)*mg.?=(_c)(_c)*<1>(_a)s.?=(mp)*(_c)*ms.?\(_isc)(_pcur)*<60>(_a)e.?=/(_isc)(_isc)<0>=(mp)(mp)*<1>(_a)s.?=(_b)(mp)*<0>(_a)(lt
20:08:19 <Keymaker> that'd be better, but i think i'll just go with the python because the language needs to do stuff with strings
20:08:35 <GregorR> Glass is great for strings ;)
20:09:05 -!- Keymaker has left (?).
21:14:54 -!- ihope has joined.
21:15:44 -!- _meat` has quit (Read error: 113 (No route to host)).
21:15:52 <ihope> I'm thinking of writing a "library" for Unlambda that would provide "better" I/O.
21:16:51 <ihope> It would be pretty similar to Lazy K's I/O system.
21:17:49 <ihope> But output gets tricky when there's no way to grab every character ever used in computing and put them all in the source file.
21:18:39 <ihope> So just which characters should I use? The ASCII printables, or all of ASCII, or extended ASCII, or...?
21:29:36 -!- Sgeo has joined.
22:15:47 <SimonRC> I mean, what is his/her online name
22:17:05 <ihope> "SADOL (Sadistic And Damn Odd Language) is a functional esoteric programming language made by Martin 'nooga' Gasperowicz (User:nooga) in 2005."
22:18:21 <SimonRC> his online hours aren't terribly convinient for me
22:34:57 <ihope> omg omg omg!!!!11 llol
22:50:06 <ihope> (And you're supposed to reply "wat io dont get it/".)
22:56:01 -!- Keymaker has joined.
23:06:27 <Keymaker> finally got back in front of computer..
23:20:08 -!- meat` has joined.
23:22:06 <SimonRC> Anyone want to hear two vaguely heretical views?
23:22:20 <SimonRC> 1) False is not Turing-complete.
23:22:35 <SimonRC> 2) SADOL isn't functional.
23:22:58 <SimonRC> 1) actually only applies if you don't mind the stack getting very large
23:23:59 <ihope> SADOL isn't functional?
23:24:27 <SimonRC> There are two interpretations of "functional"...
23:25:30 <SimonRC> The first is that functions are first-class objects and you naturally write higher-order functions. This is exemplified by the paper _Why functional programming matters_.
23:28:18 <SimonRC> The second is an idea that tends to be closely associated with the first, because languages which are functional in the first sense tend to be it also, which is being declarative. I.e. you use powerful expressions rather than loops and gotos, and variables are only assigned once.
23:28:42 <SimonRC> things like Scheme and Haskell are both of these.
23:28:58 <SimonRC> Being non-declarative is practiacally impossible in Haskell.
23:29:49 <ihope> It *is* impossible, isn't it?
23:30:41 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
23:30:43 <fizzie> Oh, it's certainly _possible_ to write ugly non-declarative-like code in Haskell.
23:30:56 <fizzie> And downright easy in Scheme.
23:30:56 <SimonRC> *cough* http://haskell.org/ghc/docs/latest/html/libraries/base/Data-IORef.html *cough*
23:31:35 <fizzie> It's even quite possible to write non-declarative-like code in Prolog, which is the first language I think of when someone says "declarative programming".
23:31:38 <SimonRC> SADOL, however, does not have firs-class functions, and some of its most important data-structure operators: [] are clearly imperative.
23:32:24 <SimonRC> FORTH-like languages can be functional in the first sense but not the second.
23:33:23 <SimonRC> However, sensible declarative langs AFAIK (I don't know Prolog) need first-class functions for the most basic stuff such as fold and map.
23:57:29 <fizzie> Prolog doesn't have functions, only predicates (well, it's pure logic), but they are arguably close to being first-class: they are built of the same kind of data the program uses (lisp-like), you can assert/retract them to add them to the program, and call then with "call".
23:58:31 <fizzie> You can't really "return" them or "pass" them, though. (There's no variable passing either, just unification, but the uses are quite close to passing and returning values.)
23:59:48 <fizzie> A variable can be unified with a predicate, but you'd need to use assert to add it to the program before it can be used.