00:09:36 -!- Asztal has quit (Read error: 113 (No route to host)).
00:53:51 -!- ivan` has quit (" HydraIRC -> http://www.hydrairc.com <- IRC with a difference").
01:32:24 -!- ivan` has joined.
01:36:58 -!- Asztal has joined.
01:39:15 -!- Asztal has quit (Client Quit).
02:28:14 -!- Renan_s2 has joined.
02:28:25 -!- Renan_s2 has left (?).
03:28:58 -!- jix_ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
03:48:30 -!- RodgerTheGreat has joined.
03:48:48 <RodgerTheGreat> howdy! What's everyone been up to during their vacation?
04:52:18 <CakeProphet> hmmm... standardization should bear in mind the option of flexibility of the standard...
04:52:40 <CakeProphet> Maybe there should be a meta-standard... some sort of standardization for how to define standards.
04:53:17 <CakeProphet> It can become impossible to change a standard once it gains inertia.
04:53:41 <CakeProphet> Unless you have some way to easily redefine your standard so that all parties are aware of the change.
04:54:19 <RodgerTheGreat> well, HTML has done a pretty good job of growing over time without breaking itself, although it's certainly starting to show it's age
04:55:03 <CakeProphet> Telnet is strangely good at allowing changes in standard.
04:55:26 <CakeProphet> since you usually do a transaction to see if both sides are simplementing the same option.
04:56:57 * CakeProphet begins crafting the "protocol protocol"... a protocol for specifying your protocol.
05:00:14 <CakeProphet> If the data contains instrunctions about the specifics of its protocol.... making changes in a protocol become less difficult.
05:01:14 <CakeProphet> how you would create such a general meta-protocol is beyond me at the moment.
05:05:31 <RodgerTheGreat> bonus points for creating a meta-protocol whose semantics themselves constitute a turing-complete system
05:07:21 <CakeProphet> Once I start working out the specifics I'll begin specifying commonly used standards and protocols in my meta-protocol... so I can work out the specifics?
05:07:32 <CakeProphet> thiink it constitutes as an esoteric language? :D: :D :D
05:07:48 <CakeProphet> Maybe if I make it with strange syntax and concepts...
05:11:12 -!- RodgerTheGreat has quit.
05:21:58 -!- CakeProphet has quit ("haaaaaaaaaa").
06:04:29 -!- CakeProphet has joined.
06:14:45 -!- calamari has quit ("Leaving").
06:32:28 <Sukoshi> CakeProphet: You can look at A/BNF for inspiration.
06:59:07 <Sukoshi> Good god, people still use QWERTY?
06:59:40 <Sukoshi> Augmented/Backus Naur Format.
07:00:15 <Sukoshi> It's pretty much the defact parser/protocol description pseudo-language, and it's used by parser generators to generate parsers for the protocols.
07:05:49 <CakeProphet> but it only expresses syntax... not what it means
07:08:19 <CakeProphet> it doesn't represent the meaning of syntax
07:08:54 <CakeProphet> the idea is to have a language for describing your standard... so that making changes to a standard simply requires you to change the metalanguage describing your standard.
07:09:25 <CakeProphet> so the inertia of a popular standard doesn't make it linger around longer than it should (like QWERTY persisting over dvorak)
07:09:38 <Sukoshi> Oh and look at the billions of other structure descriptions out there too.
07:09:51 <Sukoshi> *structure description languages
07:16:08 <CakeProphet> hmmm... xml doesn't seem to have protocol implementation in mind.
07:16:33 <CakeProphet> It's too verboose for something like that.
07:19:44 -!- oerjan has joined.
07:37:50 <CakeProphet> hehe... there should be key layout designed for programmers
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:34:57 -!- oerjan has quit ("Later").
09:27:31 <pgimeno> oh, I missed the discussion on languages of yesterday
09:33:09 <ivan`> i can't learn anything besides qwerty because i've got qwerty memorized in 20 different hand positions and have spinal reflexes for error-correction
09:33:17 <ivan`> trying to switch is the worst mental exercise ever
09:33:33 <ivan`> and 100wpm is fast enough for me
09:49:08 <pgimeno> it's like that braindamaged standard that Gnome usability "experts" are trying to impose
09:51:18 <pgimeno> (the "yes" button in the far right; the "cancel" button next to it and to the left and the "no" button next to the cancel one)
09:51:53 <pgimeno> e.g. in "Save work?" dialogs
09:55:40 <pgimeno> re languages, I think you must be a polyglot in a sufficient number of languages if you want to take different projects, since every project has a set of "adequate" languages, a set of "inadequate but feasible" languages and a set of "infeasible" languages
09:56:08 <pgimeno> here, "infeasible" means for practical purposes
09:56:47 <pgimeno> (the first two sets may even be empty)
09:59:13 <pgimeno> nobody would write an OS or a RDBMS in JavaScript (I think)
10:00:15 <pgimeno> nobody can write anything but JavaScript and (in some cases) VBScript in a web page (with a relaxed sense of "nobody" but you get the idea)
10:01:24 <pgimeno> nobody would write a program like InkScape in assembler
10:02:05 <pgimeno> nobody would write a library like GMP in anything other than assembler and C
10:02:45 <pgimeno> (aiming for the best possible speed, that is)
10:03:05 <CakeProphet> there's an orthagonally persistent operating system being written in Python.
10:03:53 <pgimeno> nobody would write a program to find (not just search) the factorization of Fermat numbers in Python
10:04:09 <pgimeno> even if it has the support needed
10:04:30 <pgimeno> I didn't exclude Python for OSes :)
10:05:31 <pgimeno> yesterday I found myself looking for the best language to write a simple application that represents a graph, with the limitation that it must support arbitrary precision (and not lots of speed)
10:07:28 <pgimeno> after checking that my PHP installation did not support GMP, I tried generating a PBM in C and viewing it with an external viewer. It worked but it required too many steps for it to be uselful to explore the graph.
10:07:59 <pgimeno> I ended up learning a bit of TkInter and writing it in Python.
10:08:22 <pgimeno> My point is that every project has an adequate language (and it can be subjective).
10:11:50 <pgimeno> (the result is here: <http://www.formauri.es/personal/pgimeno/temp/functional-art.py.txt>)
10:13:44 <pgimeno> damn, my server still breaks with python files even if they're renamed as .txt
10:16:23 <pgimeno> http://www.formauri.es/personal/pgimeno/temp/functional-art.txt
10:19:07 <pgimeno> oh, and you can write a Malbolge interpreter in Python but it's pretty slow
10:19:31 <pgimeno> (or at least that's my experience)
10:24:31 <pgimeno> the 99bob takes ages (it takes 13 million Malbolge instructions to complete IIRC, not negligible if the underlaying language is slow)
10:32:41 <CakeProphet> Python is usually adequately fast for my purposes.
10:34:08 <CakeProphet> its also the programmer that makes the program slow ;;)
11:20:59 <pgimeno> try to write a Malbolge interpreter in Python, it's pretty simple
12:02:20 <pgimeno> then compare the C version with the Python version when running 99BOB
13:43:12 -!- Asztal has joined.
14:42:30 -!- jix_ has joined.
15:02:56 -!- Asztal has quit (Read error: 113 (No route to host)).
15:06:22 -!- pikhq has joined.
15:07:08 -!- pikhq has quit (Client Quit).
15:07:22 -!- pikhq has joined.
15:07:43 <pikhq> Sorry; needed IRC in my screen session.
15:08:58 <pikhq> http://pikhq.nonlogic.org/bfm.tar.bz2
15:09:06 <pikhq> http://pikhq.nonlogic.org/basm.tar.bz2
15:09:24 <pikhq> We're under the 5000 character mark on basm. . . :)
15:32:51 <pikhq> 4629 characters for EOF=0, 4282 for EOF=-1.
15:43:15 * pikhq assumes nobody's in the mood to care ATM
16:08:12 -!- theblue has joined.
16:26:45 * pikhq wonders what to code. . .
16:29:48 <pikhq> But. . . I've already written that. . .
16:30:20 <pikhq> The programs I use kick-ass, actually.
16:30:46 <pikhq> Firefox (with Conkeror).
16:31:10 <pikhq> There is no OS but GNU, and Linux is one of it's kernels.
16:31:14 <pikhq> oklopol: Not with Conkeror.
16:31:20 <theblue> pikhq: I know, but Emacs sucks.
16:31:20 <pikhq> Gives it Emacsy bindings.
16:31:46 <oklopol> i'll prolly say it sucks if it's graphical and has a non-touring complete interface :)
16:31:46 <pikhq> theblue: Blasphemer.
16:31:59 <pikhq> Javascript is Turing complete.
16:32:13 <pikhq> It's semi-graphical.
16:32:28 <oklopol> but, the browser itself is not a console with commands that load pages etc
16:33:35 <pikhq> oklopol: Actually, with Conkeror, that's about what it is.
16:34:28 <oklopol> but i'll wait 10 years and hopefully be able to make my own systems
16:39:48 -!- Asztal has joined.
17:19:26 * pikhq feels his flesh melt from the laptop's compile job
17:34:25 -!- theblue_ has joined.
17:55:40 -!- theblue has quit (No route to host).
17:59:05 -!- oerjan has joined.
18:03:12 -!- calamari has joined.
18:05:58 <pikhq> oerjan: New release of BFM and Basm is up, if you care.
18:06:18 <pikhq> calamari: My Brainfuck->C compiler, written in BFM.
18:06:57 <calamari> ahh, was hoping it was an assembler for bf
18:07:16 <pikhq> I. . . Think you've already written on.
18:08:57 -!- theblue_ has changed nick to theblue.
18:10:53 <pikhq> basm, I believe, is now the smallest BF->C compiler in BF.
18:14:09 <pikhq> 4629 characters for EOF=0, 4282 for EOF=-1.
18:14:35 <pikhq> (the EOF=-1 build has a shorter string to output for ,)
18:15:29 <pikhq> string string2! "*p=getchar();"
18:15:42 <pikhq> String for EOF=-1.
18:15:47 <pikhq> string string2! "*p=getchar();if(feof(stdin)) *p=0;"
18:15:58 <pikhq> String for EOF=0. Makes for a good demonstration. ;)
18:16:36 <calamari> is the space necessary before *p ?
18:17:38 <calamari> might also be able to use #define to squeeze things down.. for example "if(" and "*p="
18:17:51 <oklopol> what is this: string string2!
18:18:10 <pikhq> Defines a C-style string named string2!
18:18:39 <pikhq> calamari: Yeah, but the #define would make the initially output string longer.
18:19:16 <calamari> pikhq: yeah.. you'd have to weight the #define against the savings you'd get from it
18:19:44 <pikhq> Wouldn't be worth it.
18:19:49 <pikhq> Whole line versus a small handful of characters.
18:20:05 <calamari> well, how many times do you use if( and *p= ?
18:20:23 <pikhq> p= is used thrice.
18:21:34 -!- theblue_ has joined.
18:22:03 <pikhq> The initial string-setting code really isn't that large, as it is. . .
18:22:53 <pikhq> 1976 characters for EOF=0, 1634 for EOF=-1. . .
18:22:59 <pikhq> Now that might be worth-while.
18:23:07 <oklopol> calamari, *p=p is not good
18:23:18 <oklopol> *p=feof(stdin)?0:*p; is the same length
18:24:11 <calamari> one might turn out smaller than the other, depending on his text->bf algorithm
18:24:18 <oklopol> *p*=!feof(stdin); on the other hand
18:24:39 <pikhq> My text->bf algorithm is remarkably simple.
18:24:55 <oklopol> that's the smallest possible.
18:24:59 <pikhq> For each character in the string, fill a cell using a stdcons call.
18:25:21 <calamari> might also try comma to separate commands rather than ; .. might take less charas, depending on placement
18:25:24 <pikhq> (look in macro.tcl, proc string, for the gory details)
18:25:35 <pikhq> calamari: In main().
18:25:55 <pikhq> Beyond that, I can't be certain.
18:26:20 <pikhq> And I'm not sure if the stdcons implementation of ; is shorter than ,.
18:27:03 <pikhq> oklopol: What? The language Basm is written in?
18:27:07 <calamari> pikhq: paste all the c code.. let's see what else might be optimized
18:27:10 -!- yoga has joined.
18:27:16 -!- alpha_q has joined.
18:27:28 -!- theblue has quit (Read error: 113 (No route to host)).
18:27:33 <pikhq> string string0! "#include <stdio.h>
18:27:34 <pikhq> string string1! "putchar(*p);"
18:27:36 <pikhq> if-1 { string string2! "*p=getchar();"
18:27:41 <pikhq> if0 { string string2! "*p=getchar();if(feof(stdin))*p=0;"
18:27:46 <pikhq> string string3! "while(*p)\{"
18:27:48 <pikhq> string string4! "p+="
18:27:51 <pikhq> string string5! "p-="
18:29:07 <pikhq> calamari: That parses to char b[30000]=b;char *p=b;
18:29:22 <pikhq> calamari: Pretty certain.
18:29:32 <calamari> ahh, I thought you were just outputting text
18:29:45 <pikhq> calamari: It's outputting text which is compiled into C code. -_-'
18:29:58 -!- yoga has left (?).
18:30:15 <calamari> oh, I see what you're saying.. I'm pretty sure it doesn't parse that way
18:30:27 <oklopol> i have no idea what you're even doing :)
18:31:09 <pikhq> http://pikhq.nonlogic.org/basm.tar.bz2 has the full Basm source code. . .
18:31:24 <pikhq> And http://pikhq.nonlogic.org/bfm.tar.bz2 has the BFM code necessary to compile it.
18:31:38 <pikhq> (you'll need to install Tcl and Tcllib for BFM)
18:32:31 -!- alpha_q has quit ("ako izleza ot irc s toia message znachi e stanalo neshto neobichaino").
18:33:33 -!- ihope has joined.
18:33:50 <ihope> I suddenly feel like going fast and such.
18:34:23 <pikhq> Code got borken somewhere.
18:35:46 <pikhq> That's just it. . .
18:35:57 <pikhq> It's the *logic* that's borken.
18:36:18 * pikhq disables the BFM optimizer
18:37:16 <pikhq> I think it's a BFM bug.
18:37:20 <calamari> 9<<9 = 4608, so I guess 30000 is the best you can do for 30000
18:37:47 <ihope> You know, I always thought the de facto block length thingy was a bit harsh.
18:38:23 <calamari> 5704427701027032306735164424192
18:39:01 <ihope> Not that that's too much bigger.
18:39:19 <ihope> 369729637649726772657187905628805440595668764281741102430259972423552570455277523421410650010128232727940978889548326540119429996769494359451621570193644014418071060667659301384999779999159200499899!
18:39:42 <calamari> 48217887323382029442679127207700081475263216526749012334968767476665797300622125512193927046706313615741760281289891607133421537856154131961930599086143586617705554986709039434394835722780670138450793819688709137426118735703294454016244947757346783115570384149589439754471934242436809740767425506312192
18:39:44 <ihope> 999<<(999<<(999<<(999<<(999<<999))))
18:39:58 <calamari> the idea is to have the shortest string
18:40:07 <pikhq> Yup; it was a BFM bug.
18:40:36 <pikhq> Fixed with an older build of a stdlib macro.
18:40:46 <calamari> but for length 4 or 5, regular decimal is the best you can do
18:42:14 <calamari> what I should have said is for 1000-99999, regular decimal is the best you can do
18:42:15 <oerjan> probably not portable, but what about -1>>1?
18:42:27 <ihope> let a 0 n=n^n;a m 0=a(m-1)1;a m n=a(m-1)$a m(n-1)in a 9 9
18:42:45 <ihope> ...Which, apparently, is 1.
18:43:00 <oerjan> no but the result might be bigger
18:43:03 * pikhq discovers more bugs
18:43:04 <ihope> let a 0 n=n^n+1;a m 0=a(m-1)1;a m n=a(m-1)$a m(n-1)in a 9 9
18:43:14 <ihope> That's a bit bigger.
18:43:45 <calamari> but you probably can't do char b[-1]
18:44:26 <pikhq> And I've got bugs fixed.
18:44:31 <pikhq> char b[30000],*p=b;main(){
18:45:01 <oerjan> i'm not sure of the definition of >> for negative numbers. is it implementation-dependent whether it preserves the sign bit?
18:45:01 <pikhq> *p=getchar();*p*=!feof(stdin);
18:45:05 <pikhq> That, too, works. :D
18:45:08 -!- theblue has joined.
18:45:13 <pikhq> oerjan: Pretty much.
18:45:41 <oerjan> so -1>>1 _could_ be pretty big. or maybe the precedence is wrong too.
18:46:07 <pikhq> 4466 for EOF=0, 4184 for EOF=-1.
18:46:50 <pikhq> Let me try and finish up some work on itoa and divmod; those older versions are a bit longer than they should be.
18:51:24 <pikhq> My changes to itoa.bfm and divmod.bfm somehow made the source. . . longer.
18:51:51 <calamari> pikhq: why not this? char*p[30000];main(){
18:52:53 <pikhq> calamari: Um. . . That's a pointer to an array of char arrays, I think. . .
18:53:26 <pikhq> Alternately, an array of strings.
18:56:13 -!- theblue_ has quit (Read error: 110 (Connection timed out)).
18:56:13 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
18:56:15 <EgoBot> 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl
18:56:41 <ihope> Then again, BF might be nice.
18:56:49 <ihope> Nah, Glass is better.
19:00:06 <pikhq> 4457 for EOF=0, 4175 for EOF=-1.
19:00:51 <calamari> dbc wrote one that is 874 for EOF=0
19:01:20 <calamari> http://www.hevanet.com/cristofd/brainfuck/dbf2c.b
19:01:21 <pikhq> calamari: Does his optimize?
19:01:38 <pikhq> . . . No, it sure as hell doesn't.
19:02:27 <pikhq> So, mine is still better. :)
19:02:32 <pikhq> Not smaller, but better.
19:02:47 * pikhq is going to start calling basm the smallest *optimizing* Brainfuck compiler, then.
19:02:50 <calamari> well, you had said you thought yours was the shorest, so I was clearing that up :)
19:03:33 <calamari> but, you might be able to learn some from his implementation.. he might be using some c tricks we haven't thought of yet
19:04:52 <pikhq> He's using unistd.h
19:05:35 <pikhq> Aside from that, mine's using more C tricks.
19:06:48 <pikhq> #include <unistd.h>
19:06:49 <pikhq> char r[65536],*e=r;
19:06:49 <ihope> In good ol' Glass, how do I set a variable to the thing at the top of the stack?
19:07:24 -!- ihope has set topic: #esoteric - the international hub for esoteric programming language design and deployment - map: http://www.frappr.com/esolang - forum: http://esolangs.org/forum/ - EgoBot: !help - wiki: http://esolangs.org/wiki/ - logs: http://tunes.org/~nef/logs/esoteric/ or http://meme.b9.com/cdates.html?channel=esoteric - for brainfuck-specific discussion, go to ##brainfuck - NO IRP ALLOWED - Pastebin: http://pastebin.ca/.
19:10:37 <pikhq> I refuse to use unistd.h, so I'm using all the tricks he does.
19:10:55 <pikhq> (and quite a few more: I output a grand total of 2 newlines)
19:11:06 <oerjan> http://esolangs.org/wiki/Glass
19:14:58 <ihope> That won't set the variable to 1?
19:15:25 <oerjan> that would be (name)<1>=
19:16:28 <ihope> Does that leave it on the stack or take it off?
19:18:00 <oerjan> leave it. add , to take off.
19:39:45 -!- CakeProphet has quit ("haaaaaaaaaa").
19:53:44 -!- Asztal has quit (Read error: 113 (No route to host)).
19:53:45 <oklopol> i don't like the fact that function local stuff is prefixed with an underscore, temp vars should be short imo :\
19:54:32 <oklopol> starts to feel sensible tho
19:54:48 <oerjan> ah, yes, a clear break with Glass's fundamental principle of user friendliness.
19:58:56 <oklopol> but as all names are treated as strings, you should be able to change them to strings, alter them and push them back as vars or functions
19:59:16 <oklopol> because you can do weird stuff anyway with that
20:00:14 <oklopol> i mean you can have a "function pointer" (zot) referring to any (zot)-function in any class
20:07:43 <oerjan> could be useful for dictionaries.
20:09:59 <oerjan> as in, making it not a complete pain to make dictionaries in Glass
20:10:40 <oklopol> i wasn't saying it is a bad thing
20:10:58 <oerjan> one never knows with esoteric languages :)
20:12:51 <oklopol> oh my god that is beautiful :O
20:13:04 <oklopol> {M[m(_s)S!(_o)O!<34>(_s)(ns).?"{M[m(_s)S!(_o)O!<34>(_s)(ns).?""1(_o)o.?2(_o)o.?
20:13:05 <oklopol> 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
20:13:05 <oklopol> (_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}
20:14:03 <oerjan> !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.?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(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}
20:14:07 <EgoBot> {M[m(_s)S!(_o)O!<34>(_s)(ns).?"{M[m(_s)S!(_o)O!<34>(_s)(ns).?""1(_o)o.?2(_o)o.?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(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}
20:30:03 <oerjan> It must be possible to shorten those (_o)o's...
20:33:23 <pikhq> oklopol: Glass requires a null string to return OK. . .
20:35:42 <oklopol> hard to grasp the factorial program when stupid ppl annoy me on msn :(
20:43:34 <oklopol> haha i'm so gonna make glass without names :)
20:43:47 <pikhq> . . . What's *wrong* with you?
20:44:16 <pikhq> (presumably the same thing that's wrong with the rest of us)
20:44:43 <oklopol> but, you know, nameless classes and objects
20:44:57 <oerjan> !glass {M[m(_s)S!o11O!o.=<34>(_s)(ns).?"{M[m(_s)S!o11O!o.=<34>(_s)(ns).?""1o?2o?1o?2o?2o?0o?2o?0o?]}"1o?2o?1o?2o?2o?0o?2o?0o?]}
20:45:17 <pikhq> Did I happen to mention that something is wrong with you?
20:46:18 <oklopol> actually it might be easy to make a quine but never made one, so
20:47:23 <oerjan> !glass {M[m(_s)S!(_o)11O!o.=<34>(_s)(ns).?"{M[m(_s)S!(_o)11O!o.=<34>(_s)(ns).?""1(_o)?2(_o)?1(_o)?2(_o)?2(_o)?0(_o)?2(_o)?0(_o)?]}"1(_o)?2(_o)?1(_o)?2(_o)?2(_o)?0(_o)?2(_o)?0(_o)?]}
20:47:25 <oklopol> glass has the cool idea of mixing oo and stacks, but it's basically pretty "normal", gotta add some more esoteria!!
20:48:00 <oklopol> haha, now just a few chars and it's the former one :)
20:48:25 <oerjan> i thought maybe i used the wrong namespace
20:48:38 <oerjan> but it is something else, i think
20:50:48 <oerjan> !glass {M[m(_s)S!o11O!o.=<34>(_s)(ns).*?"{M[m(_s)S!o11O!o.=<34>(_s)(ns).*?""1o*?2o*?1o*?2o*?2o*?0o*?2o*?0o*?]}"1o*?2o*?1o*?2o*?2o*?0o*?2o*?0o*?]}
20:52:03 <oklopol> i'm having a hard time figuring out how to make anything without operators...
20:52:31 <oklopol> i'd like this lang with everything being just a stack of structures
20:52:41 <oklopol> structures as in functions and classes
20:52:51 <GregorR> Woah, that's some complicated Glass code XD
20:53:15 <oerjan> actually i am just using search and replace on the quine
20:53:23 <pikhq> You have made the inventor of Glass say that. . .
20:53:24 <oerjan> to make a shorter one.
20:53:45 -!- CakeProphet has joined.
20:53:45 <GregorR> What, you think I'm the only one that can write complicated glass code? :P
20:53:58 <GregorR> I didn't write the jixmath class, and that's pretty F***ing complicated :P
20:53:59 <pikhq> GregorR: Just saying that that's quite a compliment.
20:54:44 <pikhq> (care to show me le source?)
20:55:10 <oerjan> !glass {M[m(_s)S!(_o)11O!o.=<34>(_s)(ns).*?"{M[m(_s)S!(_o)11O!o.=<34>(_s)(ns).*?""1(_o)*?2(_o)*?1(_o)*?2(_o)*?2(_o)*?0(_o)*?2(_o)*?0(_o)*?]}"1(_o)*?2(_o)*?1(_o)*?2(_o)*?2(_o)*?0(_o)*?2(_o)*?0(_o)*?]}
20:55:54 <oerjan> it's easy to make complicated code when it's wrong :(
20:56:07 <GregorR> {(JixMath)[(c)*][(c__)aA!p<9>=(ee)<2.71828182845905>=][(log)(_v)1=,(_c)<-1>=(_x)<1>=/(_x)(_v)*<1.5>a(ge).?(_x)1=(_y)1=,(_c)0*<1>aa.?=/(_y)(_v)0*(ee)*ad.?=(_c)(_y)<0>=\\(_p)p*=(_v)0*<1>as.?=(_o)(_v)*=(_s)<1>=(_i)<0>=(_x)<0>=/(_p)(_p)0*<1>as.?=(_i)0*<1>aa.?=(_x)0*(_o)*(_i)*ad.?(_s)*am.?aa.?=(_o)0*(_v)*am.?=(_s)<0>(_s)*as.?=(_x)\(_c)*(_x)*aa.?][(p)p*][(sp)p1=,][(sqrt)(_v)1=(_x)1<100>ad.?af.?=,(_q)<1>=/(_x)(_x)0*<100>ad.?af.?=(_q)0*<10>
20:56:08 -!- oklobot2 has quit (Read error: 104 (Connection reset by peer)).
20:56:13 <GregorR> am.?=\(_p)p*=/(_p)(_p)0*<1>as.?=(_q)0*(_v)*1ad.?aa.?<2>ad.?=\(_q)*]}
20:56:17 <pikhq> And. . . What does Jixmath do?
20:56:35 <pikhq> Like. . . A description?
20:56:35 <GregorR> logarithms, square roots ...
20:56:43 * pikhq sees a sqrt function. . .
20:56:56 <pikhq> jix_: I wish to pick your brain.
20:57:41 <pikhq> And salute you for that sheer craziness.
20:59:16 <pikhq> !glass {M[m(JixMath)(_m)!O(_o)!2(_m)(sqrt).(_o)o.]}
20:59:33 <jix_> uhm what's crazy about that?
20:59:34 <pikhq> My Glass might be a bit rusty.
20:59:44 <pikhq> jix_: Jixmath == crazy.
21:02:33 <oerjan> !glass {M[m(_s)S!(_a)(_o)1O!o.=<34>(_s)(ns).?"{M[m(_s)S!(_o)O!<34>(_s)(ns).?""1(_a)*?2(_a)*?1(_a)*?2(_a)*?2(_a)*?0(_a)*?2(_a)*?0(_a)*?]}"1(_a)*?2(_a)*?1(_a)*?2(_a)*?2(_a)*?0(_a)*?2(_a)*?0(_a)*?]}
21:03:15 <pikhq> !glass {M[m(_m)(Jixmath)!(_o)O!2(_m)(sqrt).?(_o)o.?]}
21:05:36 -!- ihope has quit (Connection timed out).
21:06:13 <oerjan> !glass {M[m(_s)S!o00O!o.=<34>(_s)(ns).*?"{M[m(_s)S!o00O!o.=<34>(_s)(ns).*?""1o*?2o*?1o*?2o*?2o*?0o*?2o*?0o*?]}"1o*?2o*?1o*?2o*?2o*?0o*?2o*?0o*?]}
21:07:19 <oerjan> it's that quirk about not accessing member variables from functions, I presume
21:08:27 <oklopol> !glass {M[m(_o)O!"o"(_o)o.?]}
21:08:56 <oerjan> !glass {M[m(_s)S!Q00O!o.=<34>(_s)(ns).*?"{M[m(_s)S!Q00O!o.=<34>(_s)(ns).*?""1Q*?2Q*?1Q*?2Q*?2Q*?0Q*?2Q*?0Q*?]}"1Q*?2Q*?1Q*?2Q*?2Q*?0Q*?2Q*?0Q*?]}
21:09:51 <pikhq> !glass {M[m(_o)O!(_m)(JixMath)!<4>(_m)(sqrt).?(_o)o.?]}
21:11:19 -!- Asztal has joined.
21:11:48 <CakeProphet> Switching to dvorak makes a lot of brackets no longer work.
21:14:34 <CakeProphet> ]]dgd;fg[ldfg;l';l[or=======================================================================[]]==============================================================================================================================================================='
21:15:38 <oerjan> !glass {M[m(_s)S!(_o)0O!o.<34>(_s)(ns).?"{M[m(_s)S!(_o)0O!o.<34>(_s)(ns).?""13?23?13?23?23?03?23?03?]}"13?23?13?23?23?03?23?03?]}
21:17:29 -!- ihope has joined.
21:20:44 <oerjan> !glass {T[t(_o)O!"Test"(_o)o.?]}{M[m(_t)T!(_t)t.0??]}
21:22:02 <oerjan> !glass {M[m(_o)O!"Test"(_o)o.11?11?]}
21:23:17 <CakeProphet> I'm trying to figure out how to do GLass... but it's very very difficult.
21:23:18 <oerjan> !glass {M[m(_o)0O!o."Test"02?02?]}
21:26:33 <oerjan> !glass {M[m"Test"(_o)0O!o."Test"11?11?]}
21:27:04 <CakeProphet> it's hard to follow the chain of evaluation when it goes... backwards.
21:27:34 <oerjan> !glass {M[m"Test"(_o)0O!o.11?11?]}
21:28:07 <Asztal> not if you're used to befunge
21:29:40 <oerjan> !glass {M[m(_s)S!(_o)0O!o.<34>(_s)(ns).?"{M[m(_s)S!(_o)0O!o.<34>(_s)(ns).?""14?24?14?24?24?04?24?04?]}"14?24?14?24?24?04?24?04?]}
21:29:42 <EgoBot> {M[m(_s)S!(_o)0O!o.<34>(_s)(ns).?"{M[m(_s)S!(_o)0O!o.<34>(_s)(ns).?""14?24?14?24?24?04?24?04?]}"14?24?14?24?24?04?24?04?]}
21:30:26 <oerjan> actually i just shortened one that already existed
21:30:46 <pikhq> CakeProphet: That would be a quine.
21:32:06 <CakeProphet> but it looked nice there... so I put it there.
21:32:37 -!- Asztal has quit (Read error: 113 (No route to host)).
21:32:56 <pikhq> It breaks your code, methinks.
21:33:31 <pikhq> (which pushs 1 onto the stack twice. . . And the ? tries executing 1.1, which doesn't exist)
21:33:58 <pikhq> It takes a variable referring to an instance of an object and a string referring to a function off the stack and executes it.
21:34:11 <CakeProphet> m is main... so it should execute anyways.
21:34:12 <oerjan> no, 11 copies the top 2 elements
21:34:13 <pikhq> Thus, (_o)o? would execute _o.o
21:35:06 <oerjan> and 0 copies just the top element
21:36:54 <oerjan> to use 11? the function must be on top. otherwise use 02?
21:36:59 <pikhq> That would execute Lol._o, methinks. . .
21:37:44 <pikhq> Since there is no object Lol, it does. . . Nothing.
21:38:32 <oerjan> actually it tries to execute (_o), but this fails because it is a name not a function.
21:39:02 <oerjan> for that use *? rather than ?
21:39:38 <oerjan> except that (_o) there does not contain a function either, but an object.
21:40:14 -!- Asztal has joined.
21:40:27 <oerjan> _or_ use 1? instead of (_o)*?
21:40:46 <oerjan> 1 picks up the function you already have put on the stack.
21:41:12 <CakeProphet> I have trouble figuring out what's on the stack... >.<
21:41:46 <pikhq> (_o)O! leaves nothing on the stack, but a variable (_o) define.
21:41:48 <oerjan> ah, yes. the o. doesn't work because there is no (_o) on the stack - it was removed by !
21:42:07 <pikhq> o. gives a stack underflow. . .
21:42:07 <oklopol> !glass {M[m(_a)A!<4><5>(_a)a.?(_o)O!(_o)o.1?]}
21:42:44 <oerjan> you read the specification _very_ carefully. :)
21:43:04 <oklopol> !glass {M[m(_a)A!<4><5>(_a)a.?(_o)O!(_o)o.11?]}
21:43:35 <pikhq> CakeProphet: Use the I class. . .
21:43:46 <pikhq> Unless you mean, like, arguments.
21:43:48 <oklopol> !glass {M[m(_a)A!<4><5>(_a)a.?(_o)O!(_o)o.?]}
21:44:06 <pikhq> Leave the arguments on the stack in appropriate locations.
21:44:15 <pikhq> The stack is shared.
21:44:52 <oklopol> !glass {M[m(_a)A!<4><5>(_a)a.?(_o)O!(_o)on.?]}
21:45:38 <oerjan> now i am not sure why it doesn't work
21:46:01 <oklopol> !glass {M[m(_a)A!<4><5>(_a)a.?(_o)O!(_o)(on).?]}
21:46:09 <oklopol> !glass {M[m(_a)A!<4><5>(_a)a.?(_o)O!(_o)(on).1111111111111111?]}
21:46:13 <CakeProphet> So... if "Lol" is the stack before the function is run... how do you represent "Lol" as a variable?
21:46:29 <pikhq> "Lol"(variable_name)=
21:47:00 <oklopol> CakeProphet, you're totally gotten it wrong
21:47:08 <pikhq> "Lol"'Function calling stuff here'
21:47:51 <oerjan> you mean "Lol"(variable_name)1=,
21:48:19 <pikhq> oerjan: That's if you want "Lol" on the stack *and* in a variable. ;)
21:48:21 <CakeProphet> so... in the function definition... how is the "argument" (The value on the stack before execution of the function) represented?
21:48:33 <oerjan> now, , is the pop command
21:49:08 <pikhq> "Lol"(variable_name)= works just as well. IIRC, = doesn't push anything onto the stack.
21:49:30 <oerjan> no it doesn't because the arguments are in the wrong order
21:49:54 <pikhq> CakeProphet: The function just operates on the global stack.
21:50:05 <pikhq> oerjan: Well, *that* would screw things up.
21:50:20 <CakeProphet> Right... but you can mimic the use of arguments by treating the value on the stack as input right?
21:51:01 <pikhq> CakeProphet: ! creates an instance of an object.
21:51:22 <oerjan> the 0 1 2 commands etc. makes copies of things on the stack.
21:51:23 <pikhq> Same way you would operate on something on the stack otherwise. . .
21:51:46 <oklopol> !glass {M[m(_o)O!(_o)(_a)A!(_b)B!(_c)C!f(_a)1.?(_b)1.?(_c)1.?]}{A[f0"a"1o.?]}{B[f0"b"1o.?]}{C[f0"c"1o.?]}
21:52:03 <pikhq> Imagine you've got a bunch of plates on top of each other.
21:52:18 <pikhq> push equates with sticking a plate on top. pop equates with taking one off.
21:52:27 <Asztal> sounds a lot like befunge to me.
21:52:34 <pikhq> That's the visualisation.
21:52:37 <CakeProphet> I know how they work. I just don't know when it happens.
21:52:44 <pikhq> Asztal: Well, a stack *is* a common datatype.
21:52:56 <pikhq> CakeProphet: When the command for your stack operation is executed. . .
21:53:14 <CakeProphet> 0 would be whatever came before the function then.
21:53:27 <CakeProphet> if you use it right at the beginning of the definitionl
21:53:42 <oerjan> every Glass command has a clearly specified effect on the stack, which you can look up at the wiki. In fact I wrote those descriptions myself.
21:53:46 <pikhq> You've got a copy of what's on the top of the stack.
21:54:03 <CakeProphet> which... in that case, would be (input) right?
21:54:23 <oklopol> !glass {A[f0"a"1o.?]}{B[f0"b"1o.?]}{C[f0"c"1o.?]}{M[m(_o)O!(_o)(_a)A!(_b)B!(_c)C!f(_a)1.?(_b)1.?(_c)1.?]}
21:54:31 <pikhq> Hit the Wikipedia page.
21:54:55 <oerjan> however, Glass is designed so that those effects are not always the most intuitive ones - sometimes it uses the stack for the result, sometimes a variable.
21:55:19 <oerjan> so you simply _have_ to look it up.
21:56:14 <oklopol> A, B and C have a function f that prints a char with stack operation (object of type O) -> (the same object), right?
21:56:33 <oerjan> Although the builtin class methods happen to more consistently put their results on the stack.
21:57:54 <oklopol> !glass {A[f0"a"1o.?]}{B[f0"b"1o.?]}{C[f0"c"1o.?]}{M[m(_o)O!(_o)(_a)A!(_b)B!(_c)C!f1(_a)2.?(_b)2.?(_c)2.?]}
21:58:22 <oerjan> A is a builtin class that might confuse matters.
21:58:47 * CakeProphet wonders how you would mimic inheritance with Glass.
21:59:36 <oklopol> !glass {A[f"a"1o.?]}{B[f"b"1o.?]}{C[f"c"1o.?]}{M[m(_o)O!(_o)(_a)A!(_b)B!(_c)C!f1(_a)2.?(_b)2.?(_c)2.?]}
22:00:02 <oerjan> you cannot call methods in a class directly, you must instantiate an object.
22:01:11 <CakeProphet> !glass {C[c0(_hehe)O!o.?]}{M[m"Lol"(_meow)C!c.?]}
22:01:20 <oklopol> oerjan, can you help me with mine too? :D
22:01:46 <oerjan> oklopol: i would suggest you rename the A class because there is a builtin with that name
22:02:09 * CakeProphet shall make a language that uses a queue instead of a filthy stack.
22:02:42 <oklopol> !glass {B[f"b"1o.?]}{C[f"c"1o.?]}{D[f"d"1o.?]}{M[m(_o)O!(_o)(_b)B!(_c)C!(_d)D!f1(_b)2.?(_c)2.?(_d)2.?]}
22:03:00 <oklopol> queue... the turing machine!
22:03:17 <CakeProphet> A double-ended queue would be interesting.
22:03:24 <oerjan> cakeprophet: the ! command does not leave an object nor its name on the stack. put a 0 after the object variables to keep them.
22:03:51 <CakeProphet> !glass {C[c0(_hehe)0O!o.?]}{M[m"Lol"(_meow)0C!c.?]}
22:04:05 <CakeProphet> mej... I keep thinking in evaluation mode... like Lisp
22:04:31 <CakeProphet> Whoo hoo.. I made a needless wrapper around the output class.
22:06:29 <oerjan> oklopol: you have hit upon one of the weirdities of Glass: object names are looked up in the environment of the . so the (_o) can only be used in the m function
22:07:02 <oklopol> i knew my code was right assuming my knowledge!
22:07:52 <oerjan> simply move the o. from the subclasses to M
22:08:01 <oklopol> !glass {B[f(_t)O!"b"1o.?]}{C[f(_t)O!"c"1o.?]}{D[f(_t)O!"d"1o.?]}{M[m(_o)O!(_o)(_b)B!(_c)C!(_d)D!f1(_b)2.?(_c)2.?(_d)2.?]}
22:08:11 <ihope> CakeProphet: a single-ended queue would be more interesting.
22:08:31 <CakeProphet> naj... with a double-ended you could rotate around to weird places.
22:09:30 <oerjan> ok another way is to use (_o)* in m to actually have an object rather than its name on the stack. but then you need to put it back into a variable in the subclasses before using . :)
22:10:04 <oklopol> k i'll leave that project.... xD
22:10:37 <oklopol> why didn't the temp thing work?
22:10:42 <oklopol> !glass {B[f(_t)O!"b"1o.?]}{C[f(_t)O!"c"1o.?]}{D[f(_t)O!"d"1o.?]}{M[m(_o)O!(_o)(_b)B!(_c)C!(_d)D!f1(_b)2.?(_c)2.?(_d)2.?]}
22:11:05 <oerjan> !glass {M[mTO!"Test"To.?]}
22:11:27 <oerjan> right i forgot, you can use a global variable starting with a capital :)
22:12:07 <oklopol> !glass {B[f"b"1o.?]}{C[f"c"1o.?]}{D[f"d"1o.?]}{M[m(Olp)O!(Olp)(_b)B!(_c)C!(_d)D!f1(_b)2.?(_c)2.?(_d)2.?]}
22:12:42 <oklopol> my lang is starting to get a nice feel to it, {[|<>*][(<>[1-])?]}
22:12:58 <oklopol> does factorials, tho under construction :)
22:14:28 <oklopol> a "class" now has a function stack and a var stack, each "object" lives while it has functions left.... and i have no idea about anything, but who cares :)
22:24:41 <CakeProphet> !glass {(Con)[(c__)a1=b0=][aa*^][bb*^][(iter)(_fun)0=a*(_fun)?(_fun)b(iter).?}
22:24:50 <CakeProphet> hmmm... I'm trying to build a List datatype in Glass :D
22:28:08 <oerjan> that constructor doesn't look quite right
22:29:40 <oerjan> i think [(c__)a2=b2=,,] might work better
22:31:01 <oerjan> because that way you pick the deepest remaining argument
22:32:07 <oerjan> that should be [(c__)a2=b1=]
22:32:21 <CakeProphet> hmmm... I think, to feet the typical Glass syntax... the order of the list should be in reverse :D <123><4567>(pair)(Con)! (if I did the syntax right) would be a pair starting with 4567 and ending with 123
22:32:34 <oerjan> you just forgot to include the variable names on the stack, i think
22:33:12 <oerjan> but you might still want ,, at the end to remove the arguments.
22:34:15 <oerjan> i don't think you need ^ just before ]
22:35:12 <oerjan> reversing is as simple as a1=b2=
22:37:17 <oerjan> i think you might want a comma after 0= and BTW that should be 1=
22:38:17 <CakeProphet> !glass {(Con)[(c__)a2=b1=][aa*][bb*][(iter)(_fun)1=,a*(_fun)?(_fun)b(iter)?} {M[m(_p)<123><456>(_pair)(Con)!(_o)O! (_pair)a.(_o).o? (_pair)b.(_o).o?]}
22:40:26 <CakeProphet> !glass {(Con)[(c__)a2=b1=][aa*][bb*][(iter)(_fun)1=,a*(_fun)?(_fun)b(iter)?} {M[m<123><456>(_pair)(Con)!(_o)O! (_pair)a.(_o).o? (_pair)b.(_o).o?]}
22:43:38 <oerjan> missing some *'s after some (_fun)'s
22:43:38 <CakeProphet> !glass {(Con)[(c__)a2=b1=][aa*][bb*][(iter)(_fun)1=,a*(_fun)*?(_fun)*b(iter)?} {M[m<123><456>(_pair)(Con)!(_o)O! (_pair)*a.(_o)*.o? (_pair)*b.(_o)*.o?]}
22:43:38 <CakeProphet> !glass {(Con)[(c__)a2=b1=][aa*][bb*][(iter)(_fun)1=,a*(_fun)*?(_fun)*b(iter).?} {M[m<123><456>(_pair)(Con)!(_o)O! (_pair)*a.(_o)*.o? (_pair)*b.(_o)*.o?]}
22:43:38 <CakeProphet> hehe... I'm assuming glass can handle recursiion.
22:43:38 <CakeProphet> !glass {(Con)[(c__)a2=b1=][aa*][bb*][(iter)(_fun)1=,a*(_fun)*?(_fun)*b(iter).?]} {M[m<123><456>(_pair)(Con)!(_o)O! (_pair)*a.(_o)*.o? (_pair)*b.(_o)*.o?]}
22:43:38 <CakeProphet> I'm going to make a list class to conviently wrap values into pairs before I attempt any sort of iteration. O.o
22:43:38 <oerjan> too many * in the main function
22:43:38 <CakeProphet> I thought you needed them to denote that the variable is in the current context. ;.;
22:43:39 <oerjan> not for the argument of .
22:44:36 <CakeProphet> !glass {(Con)[(c__)a2=b1=][aa*][bb*][(iter)(_fun)1=,a*(_fun)*?(_fun)*b(iter).?]} {M[m<123><456>(_pair)(Con)!(_o)O! (_pair)a.(_o)o.? (_pair)b.(_o)o.?]}
22:45:39 <oerjan> oh and numbers are printed with on. not o.
22:46:03 <CakeProphet> !glass {(Con)[(c__)a2=b1=][aa*][bb*][(iter)(_fun)1=,a*(_fun)*?(_fun)*b(iter).?]} {M[m<123><456>(_pair)(Con)!(_o)O! (_pair)a.(_o)(on).? (_pair)b.(_o)(on).?]}
22:47:33 <CakeProphet> wheee.... slowly the process of abstraction takes place.
22:47:39 <oerjan> whoops. i remember that you cannot have methods with the same name as attributes.
22:47:54 <CakeProphet> meh... I'll call them what they're called in Lisp.
22:47:58 <oerjan> in fact it crashed Glass horribly last time i tried
22:48:38 <CakeProphet> hmmm... can't you just access the variables themselves?
22:48:59 <oerjan> no, that was in fact what crashed Glass horribly, it's a bug
22:49:41 <CakeProphet> !glass {(Con)[(c__)a2=b1=][(car)a*][(cdr)b*][(iter)(_fun)1=,a*(_fun)*?(_fun)*b(iter).?]} {M[m<123><456>(_pair)(Con)!(_o)O! (_pair)(car).?(_o)(on).? (_pair)(cdr).?(_o)(on).?]}
22:50:43 <oerjan> i think the (iter) is still slightly buggy
22:50:47 <CakeProphet> It instantiated... took the two values in front of it, stored them, and accessed them.
22:51:15 <CakeProphet> yeah... I'll wait for the (List) class before figuring out the iter
22:51:53 <CakeProphet> (List) will probably need to take the length of the list as a value... so the constructor knows how far back to go.
22:53:20 -!- jix_ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:54:04 <oerjan> you need a Nil class for a start
22:55:14 -!- jix_ has joined.
22:55:16 <oerjan> rather, {(Nil)[(iter),]}
22:56:32 <oerjan> and probably you need a null? method too
23:00:43 <oerjan> actually that could be defined using (iter).
23:01:29 <oerjan> except... that would be bad on circular lists.
23:02:03 <CakeProphet> {(Nil)[(iter),][(null?)1]} {(Con)[(c__)a2=b1=][(car)a*][(cdr)b*][(iter)(_fun)1=,a*(_fun)*?(_fun)*b(iter).?]} {(List)[(c__) (_a)A! (length)0=(tmp)(length)*=\(tmp)*a(tmp)*=b(tmp)<(tmp)*><1>(_a)s.?==]}
23:02:18 <CakeProphet> hmmm... not done yet on the constructor for list.
23:03:03 <oerjan> you need (null?) in (Con) as well
23:04:28 <oerjan> null? is just a method that tells if the list is Nil or not. So Con can just return 0.
23:07:26 <CakeProphet> How would you change a <number> into a (stack push)?
23:08:36 <oerjan> i think that is rather awkward. in fact i think you would need to create a list class just to temporarily store away the above elements.
23:10:14 <oerjan> i don't think you need the (tmp) variable btw. just decrement length in the loop.
23:10:23 <CakeProphet> I'm trying to use a length parameter and a while loop to make it do a bunch of cons
23:10:55 <CakeProphet> Well... I was going to keep length unchanged by the loop so that it could be accessed by other things
23:11:35 <oerjan> but you don't need it i think
23:12:17 <CakeProphet> In an environment built around getting values based on their position on the stack... a length variable would come in handy in tons of places.
23:12:58 <CakeProphet> but I'm still not sure how to use tmp to get something from the stack./
23:13:53 <oerjan> you cannot. the simplest way to turn a number into a push is by using the List class you are trying to construct.
23:14:31 <oerjan> however if you do the loop the right way you don't need to access far down elements.
23:15:20 <oerjan> you may not even need 0.
23:17:44 <oerjan> if you are collecting elements into the variable (_l), say, then adding the top element of the stack to it (and removing it) is just (_l)*(_l)(Con)!
23:18:20 <oerjan> except you need to add those ,, i mentioned at the end of (Con).c__
23:18:24 -!- Asztal has quit (Read error: 113 (No route to host)).
23:21:33 <oerjan> so your loop would be something like /(_tmp)(_l)*(_l)(Con)!(_tmp)*<1>(_a)s.?\
23:22:25 <oerjan> _l is the variable collecting the list
23:24:01 <oerjan> (_l)(Nil)!/(_tmp)(_l)*(_l)(Con)!(_tmp)0*<1>(_a)s.?=\
23:25:59 <CakeProphet> Your *'s look like they're in the wrong place.
23:27:10 <oerjan> the first * is to get the content of _l onto the stack before using (Con)
23:28:30 <oerjan> because the ! command takes an unevaluated name to put the contructed object in
23:29:04 <CakeProphet> I forgot the _1 was just an identifier name.
23:31:15 <oerjan> it may not really be appropriate for this list collection function to happen in List.c__, because we are not actually trying to construct a class List object, but a chain of Con's
23:32:14 <CakeProphet> it's probably the easiest way I could think of doinging
23:32:21 <CakeProphet> implementing it as a method of Con would be kind of weird.
23:32:32 <oerjan> the problem is that we then get a new List object in addition
23:32:55 <CakeProphet> If the constructer simply returns _l... it'll be a chain of cons.
23:33:14 <CakeProphet> by "return" I mean... but _l on the stack.
23:33:39 <oerjan> yes, but the List object still is also created, and needs to be put in a variable
23:34:03 <CakeProphet> Hmmm... it wouldn't work right as a Con method though...
23:35:01 <CakeProphet> hmmm... maybe _l should be an instance variable?
23:35:19 <oerjan> it could be List.list, that would be similar to the builtin classes
23:36:13 <oerjan> the builtin classes just need to be instantiated once, and after that you use their methods as if they were static
23:38:30 <oerjan> on the other hand wrapping the List object might also work, but then you need to declare (iter) and stuff in (List) as well.
23:39:31 <oerjan> anyhow now i really need to go to bed
23:39:57 -!- oerjan has quit ("Good night.").
23:43:28 <CakeProphet> {(Nil)[(iter),][(null?)1]} {(Con) [(c__)a2=b1=] [(car)a*] [(cdr)b*] [(null?)0] [(iter)(_fun)1=,a*(_fun)*?(_fun)*b(iter).?] } {(List)[(build)(_a)A!(_tmp)0= (_list)(Nil)!/(_tmp)(_list)*(_list)(Con)!(_tmp)0*<1>(_a)s.?=\(_list)] } {M[m(_o)O! (_l)(List)! "H" "e" "l" "l" "o" " " "W" "o" "r" "l" "d" "!"<12>(_l)(build).?(MyList)0= (_o)o.(MyList)(iter).?]}
23:44:03 <CakeProphet> !glass {(Nil)[(iter),][(null?)1]} {(Con) [(c__)a2=b1=] [(car)a*] [(cdr)b*] [(null?)0] [(iter)(_fun)1=,a*(_fun)*?(_fun)*b(iter).?] } {(List)[(build)(_a)A!(_tmp)0= (_list)(Nil)!/(_tmp)(_list)*(_list)(Con)!(_tmp)0*<1>(_a)s.?=\(_list)] } {M[m(_o)O! (_l)(List)! "H" "e" "l" "l" "o" " " "W" "o" "r" "l" "d" "!"<12>(_l)(build).?(MyList)0= (_o)o.(MyList)(iter).?]
23:54:47 <CakeProphet> Would probably make a good built-in class.
23:55:53 <pikhq> My god. You're just crazy.
23:56:47 <CakeProphet> The cons class works fine... just need to figure out where I messed up on the list constructor.
23:57:45 <CakeProphet> !glass {(Nil)[(iter),][(null?)1]} {(Con) [(c__)a2=b1=] [(car)a*] [(cdr)b*] [(null?)0] [(iter)(_fun)1=,a*(_fun)*?(_fun)*b(iter).?] } {(List)[(build)(_a)A!(_tmp)0= (_list)(Nil)!/(_tmp)(_list)*(_list)(Con)!(_tmp)0*<1>(_a)s.?=\(_list)] } {M[m(_o)O! (_l)(List)! "H" "e" "l" "l" "o" " " "W" "o" "r" "l" "d" "!"<12>(_l)(build).?(MyList)0= (_o)o.(MyList)(iter).?]}
23:59:54 -!- tgwizard has quit (Remote closed the connection).