00:50:56 -!- ehird` has changed nick to ehirdsleep.
00:51:48 <pikhq> Gregor, you bastard. :p
01:53:47 -!- Sgeo has joined.
01:54:46 <Sgeo> Hi all bye all.
02:02:40 <Slereah-> ``m``s``bs``b`s``c``b``c`t`k0ki#``c``bc``c``bc``b`ci`k.xri``c``bb``sii``b``c``bc``b`bc``c``bc``b`bb``cb``b`bttkii``sb``sbi
02:02:55 <Slereah-> Maybe now, 99 bottles of beer!
02:03:21 <Sgeo> Maybe, MAYBE, I'll start working on PSOX again tomorrow
02:03:26 <Sgeo> Anyone have any comments about PSOX?
02:17:15 <pikhq> (then I can make my Macro Language to End All Macro Languages working. :p)
02:18:49 * pikhq thinks: language which is moderately full-featured, supporting PSOX: crazy? :p
02:19:50 <pikhq> Lessee here. . . lnum foo=2, anyone?
02:22:34 <pikhq> "foo+=2" would also work, thanks to types. ;p
02:22:46 <Sgeo> Would this language support the REGEX type?
02:22:59 <pikhq> That would be tricky.
02:23:39 <pikhq> Particularly since I'm thinking of managing operator overloading to handle the types.
02:23:49 <pikhq> (without classes. Just macros. I'm insane. ;))
02:26:59 <pikhq> Perhaps "new_type lnum;macro lnum_+(x, y){psox_call(ADD_LNUM, x, y);}" etc.
02:31:55 <pikhq> The name change happened ages ago, people! :p
02:32:59 <pikhq> Sgeo: You know what would be *truly* insane? A way of calling C functions from PSOX.
02:33:16 <Sgeo> pikhq, go write a Domain for it, if you wantr
03:02:35 <GreaseMonkey> hey guys, i just made a BF interpreter in about 5 minutes
03:03:07 <Slereah-> That's because Python is awesome.
03:11:53 <pikhq> And because you have been crippled by your lack of malloc.
03:16:20 <oklopol> i think i've written one in less than 3 minutes, but i just wrote the same program and took time :-)
03:38:28 <oklopol> GreaseMonkey: bs.append(i) is faster than bs+=[i]
03:39:12 <oklopol> python will actually do bs = bs + [i], baking a list of i, then concatenating the two lists baking a third list
03:40:44 <oklopol> oh, also bs.pop() for bs=bs[:-1]
03:41:00 * oklopol thinks that's a Very Crappy System
03:41:38 -!- oklopol has quit ("for the need to encumber").
03:42:24 -!- oklopol has joined.
03:42:34 <oklopol> how do i always manage to do that...
03:43:30 <Slereah-> [04:41] <GreaseMonkey> well, it works.
03:43:31 <Slereah-> [04:41] <GreaseMonkey> and i will take note of that.
03:44:26 <Slereah-> You can't change part of a string.
03:44:41 <oklopol> then the first one is the only possibility
03:45:05 <oklopol> if you do that lots, you can do inp=list(inpt)
03:45:59 * oklopol thinks that's a crappy system too
03:46:19 <oklopol> dunno... python just lacks beauty...
03:46:32 <oklopol> unlike GRAPHICA, HAVE I MENTIONED GRAPHICA
03:46:58 <oklopol> i had some totally awesome ideas for it
03:47:10 <oklopol> and here i am, idling and wondering why i'm not coding it.
03:47:19 <oklopol> i'll get something to drink, and then code something
03:58:37 -!- Slereah- has quit.
04:04:54 -!- Untitled-13615D has joined.
04:06:53 -!- Untitled-13615D has changed nick to Slereah.
04:08:00 <Slereah> I don't know how many data I've lost because of it.
04:15:34 -!- lament has joined.
04:15:41 <lament> I have returned to rule over your channel once again!
04:15:56 <lament> Pray for mercy, and you might be spared!
04:30:09 <Slereah> Aw hell. Now the lazy evaluation is playing tricks on me for the input!
04:30:10 -!- Sgeo has quit (Remote closed the connection).
04:30:42 <Slereah> I'll have to find a way to turn it the right way
04:32:07 <lament> everybody knows lazy evaluation and i/o are incompatible :)
04:32:41 <oklopol> everybody knows kung fu fighting
04:36:58 <Slereah> I just have to make some lambda expression for the input to be evaluated first, then placed at the end.
04:38:10 <Slereah> Although it would have to be evaluated after.
04:38:52 <Slereah> I really don't want to make an anti-d combinator.
05:30:54 -!- calamari has joined.
06:05:22 -!- calamari has quit ("Leaving").
06:07:28 -!- immibis has joined.
06:50:36 -!- immibis has quit ("Hi Im a qit msg virus. Pls rplce ur old qit msg wit tis 1 & hlp me tk ovr th wrld of IRC. Man who run behind car get exhauste).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:50:23 -!- GreaseMonkey has quit ("Hi Im a qit msg virus. Pls rplce ur old qit msg wit tis 1 & hlp me tk ovr th wrld of IRC. Man who run behind car get exhauste).
08:55:17 <AnMaster> Slereah, <Untitled-13615D> Anyone knows how to disable the automatic windows update? <-- sure, 1) change to linux
08:56:13 <AnMaster> and 2) somewhere under "my computer" -> right click -> properties -> somewhere
08:56:27 * AnMaster haven't used windows for years
09:00:02 <Slereah> I'm just not that computer savvy.
09:06:41 <cherez> I found the Ubuntu installation at least an order of magnitude easier than the XP installation.
09:07:20 <cherez> But immediately after confirming the Ubuntu was that easy, I installed Gentoo by hand, so I might not be the right demographic.
09:07:37 <Slereah> Problem is, I want both on my computers.
09:08:13 <Slereah> For instance, to run most commercially released softwares!
09:09:15 <cherez> I've never met anyone who used more than a tiny fraction of commercially released software.
09:12:55 <Slereah> Well, one would be enough.
09:21:45 <Slereah> No idea, since I can't install it!
09:23:17 <cherez> How did you try to install it?
09:23:49 <cherez> Did you try the guide?
09:24:55 <Slereah> After I installed it, I couldn't run either Windows or Linux.
10:08:25 -!- jix has joined.
10:24:04 -!- jix has quit ("CommandQ").
11:09:35 -!- johnl has quit (Read error: 104 (Connection reset by peer)).
11:13:54 -!- puzzlet_ has quit (Remote closed the connection).
11:14:01 -!- puzzlet has joined.
12:17:26 -!- Tritonio__ has quit ("Bye...").
12:42:08 -!- Visitor-CD3F3 has joined.
12:52:51 -!- Slereah has quit (Read error: 110 (Connection timed out)).
13:05:38 -!- timotiis has joined.
13:49:28 -!- jix has joined.
15:25:44 -!- Visitor-CD3F3 has changed nick to Slereah.
15:28:49 -!- jix has quit (Read error: 145 (Connection timed out)).
15:30:07 -!- jix has joined.
15:42:16 -!- ehirdsleep has changed nick to ehird`.
15:43:33 <ehird`> i have some kind of obsession with writing scheme interpreters...
15:43:37 <ehird`> i'm writing one in javascript, now
15:47:26 <oklopol> some fishes and some noodles, trallalalalaa
15:55:47 <AnMaster> game of life is turing complete right+
15:56:37 <ehird`> there's a turing machine in it
15:56:40 <ehird`> see: Golly distribution
15:56:47 <ehird`> but, don't even *bother*, kind of thing
15:57:04 <ehird`> you can do it but many civilizations will pass before you get anything useful to happen
15:57:14 <ehird`> beyond counting in hexadecimal which there is a working Life file for.
15:57:42 <AnMaster> I have made some insane stuff now. while not turing complete (because of too slow and limited size) I implemented game of life inside a single player rpg, using "floor tiles" in it and some scripting in it's special language
15:58:03 <AnMaster> did that last week when my PC was broken and I had to use my old (from around 1997) mac
15:58:04 <ehird`> speed hsa nothing to do with turing completeness :)
15:58:19 <AnMaster> sadly the game engine is some shareware thing
15:58:37 -!- Jontte has joined.
15:58:48 <ehird`> AnMaster: you wrote brainfuck in bash: now do scheme
15:58:49 <AnMaster> ehird`, yes, indeed, an "area" in that game engine is limited to at most 64x64 tiles, so...
15:58:59 <AnMaster> ehird`, I don't have time currently
15:59:51 <AnMaster> oh btw that game engine, had weird scripting language, for example if you nested a loop, all variables from the outer loop got unset, so what I did was use some if to reset variable at end of loop if reaching edge of board and such
16:00:11 <ehird`> nesting loop idiocy reminds me of BestFriends.js
16:00:17 <ehird`> the wiki page helpfully says:
16:00:24 <ehird`> Note: YOU CANNOT use nested loops in BestFriends.js
16:00:37 <ehird`> AnMaster: a pseudo-brainfuck thing in javascript.
16:00:46 <ehird`> the wiki page is HILARIOUS
16:00:52 <AnMaster> well, it isn't brainfuck if it can't handle nested loops
16:00:59 <ehird`> http://esolangs.org/wiki/BestFriends.js
16:01:14 <oklopol> ehird`: what i said had nothing to do with anything
16:01:30 <ehird`> New enterprise features like 2d! But you CANNOT use nested loops, sorry. Also, the input command doesn't work in v32.34
16:01:36 <ehird`> We are working on this difficult problem!
16:02:07 <ehird`> it is turing complete though :|
16:02:14 <ehird`> because you can run JS' eval()
16:02:27 <ehird`> AnMaster: from: "Puts the first character of the input string in the current memory cell. As of the first version, this command does not work. The problem is being looked at carefully."
16:03:14 <ehird`> str.slice(pos,-1).index("]")
16:03:33 <AnMaster> "Turns the program pointer 90 degrees left (anticlockwise)."?
16:03:43 <ehird`> http://www.thegriddle.net/BestFriends/BestFriends.js oh jeez
16:03:52 <ehird`> they use a global var pointing to the start of the loop XD
16:04:23 -!- faxlore has joined.
16:04:23 <ehird`> '*** Each row should be the same length. See the sample below for an example of how it's used.
16:04:26 <ehird`> the example is off by one char
16:04:31 <ehird`> one of the lines is one char longer than the other
16:04:38 * AnMaster ponders some semi-object orientation in bash
16:05:32 <ehird`> you have arrays, so just store the data as an array
16:05:35 <AnMaster> but is it possible without eval?
16:06:15 <faxlore> actually I don't think I want to know :P
16:06:31 <AnMaster> but as bash is turing complete it SHOULD be possible
16:06:44 <AnMaster> you write a bash++ interpreter coded in bash! :D
16:07:19 <ehird`> obj = array of entries
16:07:27 <ehird`> entry = array with [0] = method or prop
16:07:45 <AnMaster> array can't have strings as indexes
16:07:49 <ehird`> class = array of keys, where if class[i] = key, obj[i] = value bound to key
16:08:21 <AnMaster> so I'd have to use my libhash (that doesn't do hashes really, just associative arrays)
16:09:01 <AnMaster> using variable names like hsh_myhash_fe1482b9afd
16:09:12 <ehird`> please see what i said
16:09:38 <AnMaster> ehird`, however, lookup speed would be terrible
16:09:51 <ehird`> correction: speed would be terrible
16:10:03 <ehird`> The Little Schemer's environments does something similar, btw
16:10:30 * AnMaster points to his irc bot in bash at envbot.org, got decent speed
16:10:31 <ehird`> the best book about recursion
16:10:37 <ehird`> it teaches you to think recursively
16:10:58 <ehird`> it usess Scheme as its language but that's not the point, you can easily go through it without a scheme system
16:11:04 <ehird`> it's well worth a read
16:11:06 <AnMaster> ehird`, I'm thinking about the big O all the time ;P
16:11:22 <ehird`> faxlore: he's an imperative weenie?
16:11:24 <AnMaster> well for a functional language it makes sense
16:11:37 <AnMaster> and when I use lisp I do use recursion
16:12:05 <ehird`> the question, anmaster, is - why do you use an inferior language which doesn't support such expressive coding of algorithms?
16:12:12 <faxlore> well you should avoid recursion in C when you want TCO
16:12:17 <ehird`> because of your biases against lisp that you've got from other people, I bet.
16:12:18 <faxlore> otherwise.. use a real language?
16:12:33 <ehird`> faxlore: well yeah, if you're using C then the only thiing you should be doing is writing an interpreter or something ;)
16:12:39 <AnMaster> I do use lisp a lot, I'm an emacs user
16:13:07 <AnMaster> http://envbot.org/trac/browser/anmaster-trunk/lib/hash.sh <-- not nice code, but works
16:13:23 <AnMaster> ehird`, hm? what is the difference, they certainly have a lot in common
16:13:45 <ehird`> AnMaster: elisp is a hacky, horribly-designed and implemented language that happens to have a lot of parentheses
16:13:56 <ehird`> faxlore: stfu let me take that metaphor :P
16:14:28 <ehird`> faxlore: great minds! ... and sheep
16:31:37 -!- sebbu2 has joined.
16:36:42 -!- oerjan has joined.
16:37:42 -!- oerjan has quit (Client Quit).
16:39:40 -!- oerjan has joined.
16:41:38 <ehird`> i think R5RS scheme was designed by people who hate implementors
16:42:08 <faxlore> I like this new approach to language design
16:42:22 <ehird`> 'how can we make a language that looks so elegant and simple PURE LIQUID DEATH to implement?'
16:42:38 <ehird`> 'mwahahaha! now all implementors will commit suicide and we shall RULE THE WORLD!'
16:44:34 <ehird`> however, i still implement it anyway
16:44:47 <ehird`> anyone have a favourite language they want a scheme in? :P
16:45:49 -!- sebbu has quit (Success).
16:46:28 <oerjan> given that someone already made a scheme in unlambda...
16:49:17 <oerjan> is there one in brainfuck btw?
16:50:06 <oerjan> nowhere near as painful as in Malbolge, i trust
16:52:09 <ehird`> because fitting that stuff into a tape-heap thing is PAINFUL
16:54:10 <faxlore> maybe make a scheme -> bf, then a scheme in scheme ... and
16:54:11 <oklopol> scheme in unlambda? fully compliant to the spec?
16:55:09 <ehird`> faxlore: scm->bf is the hard bit
16:55:11 <ehird`> oklopol: obviously not
16:55:19 <ehird`> oklopol: although it might have continuations, i mean that's not vey hard with c
16:55:33 <ehird`> r5rs is small but not trivial
16:55:45 <ehird`> it is Liquid Flaming Death to implement 100%, even in C or whatever
16:55:52 <ehird`> but a small subset is easy
16:56:41 <oklopol> indeed, it would be hard to do it in unlambda, i just don't think it's *obvious* it's not full r5rs
16:57:23 <ehird`> have you ever read r5rs
16:57:29 <ehird`> implementing that in unlambda is just silly..
16:57:47 <ehird`> and there's no point i mean once you have the basic scheme its just tedious function after function after that.
16:58:09 <ehird`> oklopol: it would need vectors
16:58:16 <ehird`> do you think it would have VECTORS?
16:58:18 <oerjan> i think the scheme-alike in question has no mutable data, like unlambda
16:58:40 <ehird`> oklopol: lookup time has to be O(1)
16:58:46 <ehird`> you acn't have that with a linked list
16:58:57 <oklopol> i must have not payed attention
16:59:14 <oklopol> i recall "vectors are usually faster in lookups"
16:59:51 <oklopol> specifying ordos is interesting because it actually may disallow implementation in many languages
17:00:50 <ehird`> obviously a toy unlambda impl won't do all scheme
17:01:00 <ehird`> because it's pretty redundant, you don't get extra cool points beyond call/cc
17:02:38 <ehird`> is there any native-code INTERCAL compiler?
17:02:41 <ehird`> preferably optimizing :D
17:02:50 <oklopol> yeah, doesn't specify access time of course
17:03:38 <oklopol> pretty redundant? it'd be awesome to make a full scheme in unlambda
17:03:45 <ehird`> oklopol: no, it wouldn't
17:04:12 <ehird`> someone tell oklopol he's wrong
17:06:37 <oklopol> and i'm not wrong, why not do it good if you're gonna do it
17:07:21 <oerjan> basically, once you add mutable structures you have to pass a simulated heap...
17:09:32 <ehird`> any other language suggestions for a scheme? ;)
17:09:37 <oklopol> if there's no mutable structures, i'd hardly even call it a scheme
17:09:58 <oerjan> might even be fairly doable...
17:10:00 <faxlore> ehird`: Do it in Agda2 or Coq or Epigram or something
17:10:23 <ehird`> faxlore: never heard of any of those but Coq
17:11:03 <ehird`> oklopol: everyone's done that ;)
17:11:24 <ehird`> wroten some kind of lisp interpreter in a minimal lisp
17:11:41 <oklopol> i have no idea what that has to do with anything, though
17:11:42 <ehird`> oerjan: the parser will be difficult in befunge :)
17:11:48 <ehird`> oerjan: i assume you mean befunge-98 btw?
17:12:18 * ehird` tries to think of a pun involving Befunge and Scheme to use as a name
17:12:41 <oklopol> oerjan said you need to simulate a heap to have mutable structures, i said if it does not have mutable structures, it's so far from the spec i'd hardly call it scheme
17:12:42 <ehird`> hm i haven't got a befunge implementation here
17:12:49 <ehird`> what's the best (i.e. fastest) interpreter out there right now?
17:12:54 <oerjan> parser for scheme difficult?
17:13:11 <ehird`> oerjan: in befunge yeah :)
17:13:17 <oklopol> if it lacks mutable structures, you cannot reason with it as you can with scheme, making it definitely less powerful
17:13:26 <ehird`> oklopol: your >>> sch has no mutable structures
17:13:30 <oklopol> just lacking vectors doesn't matter much
17:13:33 <ehird`> no set-car! or set-cdr!
17:13:36 <oklopol> indeed, i'd hardly call it a scheme
17:13:46 <oklopol> that doesn't have anything to do with anything either
17:13:47 <ehird`> um mutability IMPACTS on your reasoning
17:13:51 <oerjan> oklopol: well it was a subset of scheme + unlambda-specific functions
17:14:03 <ehird`> in fact, PLT Scheme 4.0 makes all cons pairs IMMUTABLE by default
17:14:15 <ehird`> you need to use mcons/mcar/mcdr/mset-car!/mset-cdr! for mutability
17:14:20 <ehird`> and PLT is one of the big-uns in scheme
17:15:06 <oklopol> i'm not saying being immutable is bad, i'm saying if structures are immutable, you cannot use it as you might want to use scheme.
17:15:34 <oklopol> which means many scheme programs would have to dramatically change structure to be convertible to an immutable scheme
17:15:44 <oklopol> i'd hardly call such a scheme a scheme
17:15:46 <ehird`> oerjan: my befunge program will be ugly! since i'm commenting it to hell it'll probably look more like a brainfuck program with funny symbols than befunge, heh
17:16:07 <ehird`> oklopol: most scheme programs don't use set-car!/cdr!
17:16:27 <ehird`> which is why PLT - which is the most popular implementation of Scheme (unless this has changed) - is switching
17:16:30 <oklopol> umm no, but many scheme programs do use some mutable features.
17:16:53 <oerjan> mutable _variables_ are the rule
17:16:54 <oklopol> dunno, that's just what i've heard from schemere
17:17:09 <oklopol> hmm, oerjan makes a good point
17:17:20 <ehird`> oerjan: but i would wager that unlambda interp had them.
17:17:37 <ehird`> if you have environments in unlambda you're already doing crazy operations, updating of values would be trivial
17:18:07 <oerjan> no, it isn't. for full mutability of environments you need a heap
17:18:21 <oklopol> without mutable structures, making scheme in unlambda shouldn't be that hard, basically conversion to pointless & list support
17:18:41 -!- sebbu has joined.
17:19:11 <ehird`> who knows what the best befunge implementation is.
17:19:17 <ehird`> maybe best error messages ;)
17:19:28 <oerjan> i don't recall whether it supported mutual recursion or just did macro expansion of definitions (like the lazy-K scheme afaiu)
17:19:53 <ehird`> lazy k's macrolanguage is not scheme
17:20:03 <ehird`> it's written in scheme and uses s-expressions
17:21:26 <ehird`> it's closer to lambda calculus with macros than scheme
17:36:30 -!- sebbu2 has quit (Connection timed out).
17:44:49 -!- sebbu2 has joined.
17:56:12 -!- timotiis has quit ("leaving").
17:56:16 * faxlore doesn't understand the question
17:59:11 <ehird`> where best is mainly determined by: fastest, and nice error messages
18:03:00 -!- sebbu has quit (Connection timed out).
18:03:00 -!- sebbu2 has changed nick to sebbu.
18:07:35 -!- timotiis has joined.
18:16:04 -!- sebbu2 has joined.
18:29:14 <ehird`> I guess I could write my own :P
18:31:35 <ehird`> What would I do with 8 cores?
18:33:36 <ehird`> ... Run befunge probably.
18:34:09 -!- sebbu has quit (Connection timed out).
18:34:10 -!- sebbu2 has changed nick to sebbu.
18:45:58 <ehird`> Someone suggst a different langugae :P
18:46:33 -!- Hiato has joined.
18:46:36 -!- sebbu2 has joined.
18:49:00 <Hiato> let me cut to the chase: The Acronym spec is now complete, an now it's interpreter time. What language should be the primary choice for this (needs to hold fairly large arrays of Int32, in two dimensions to create the 128x128 grid twice, also needs to have an easy if/else if/case/switch/when structure). Any suggestions?
18:49:31 <faxlore> Hiato: Just use whatever you enjoy programming in
18:50:21 <Hiato> Sure, ok, thanks faxlore (because I received a couple of long stares when I wrote the Full 0 interpreter in Delphi last time ;) )
18:51:30 <Hiato> Like Pascal, but different
18:52:24 <ehird`> would 'infinite' be better?
18:52:43 <Hiato> yes, I suppose, but the spec specified that
18:52:50 <Hiato> I don't mind though, I'll change the spec
18:52:57 <Hiato> blah, ok, hold on 1 sec
18:54:36 -!- ehird` has quit.
18:55:38 <Hiato> http://rafb.net/p/rPclV323.txt
18:55:56 <Hiato> ok, well it's there anyways
18:58:11 -!- ehird` has joined.
18:58:17 <ehird`> sorry, hiato. irc client troubles.
18:58:28 <Hiato> http://rafb.net/p/rPclV323.txt
18:58:32 <ehird`> anyway, i'll write an interpreter in scheme, with infinite arrays instead of restricted
18:58:41 <Hiato> here you go, stuff is misaligned because of wordpad
18:58:45 <ehird`> by the same token it will be able to run in a browser, once i get my implementation written :P
18:59:43 <Hiato> so you'll write an ACRONYM interpreter in scheme?
18:59:47 <oklopol> how much change since last version?
18:59:56 <ehird`> Hiato: yeah, when i find the time
19:00:02 <ehird`> unless it's self modifying
19:00:12 <Hiato> no, it's not, no worries
19:00:36 <ehird`> Hiato: do they have to be int32s?
19:00:38 <ehird`> or can they be bignums
19:00:39 <Hiato> oklopol: some technical things and a couple of new tidbits
19:00:48 <oklopol> compiling a self-modifying language might be interesting
19:00:52 <Hiato> Sure, bignums = all the better
19:00:56 <ehird`> oklopol: it's been done.
19:01:07 <Hiato> I was about to say that :P
19:01:11 <ehird`> Hiato: ok, remove the fixed size restrictions from the spec and i'll do it :D
19:01:16 <oklopol> doesn't make it less interesting
19:01:26 <ehird`> otherwise i will have a language-strikingly-similar-to-ACRONYM implementations
19:01:30 <ehird`> instead of an ACRONYM implementation
19:01:52 <Hiato> I am changing it now :)
19:02:48 <ehird`> it'll also make it turing complete
19:04:13 -!- sebbu has quit (Connection timed out).
19:05:37 <Hiato> "Each grid cell can store any arbitrary integer." is that better than Int32?
19:06:03 <ehird`> positive and negative, right??
19:06:27 <ehird`> also, don't bother specifying about dynamic reallocation of the grid, just say 'grid of infinite size' and let the implementors do what they want
19:06:35 <ehird`> for, e.g., future implementaiton on an infinite-memory machine ;)
19:06:59 <Hiato> I will change as needed, thanks or the heads up ;)
19:07:57 <ehird`> also, 3x2 commands? i see many one-char commands
19:08:18 <ehird`> the command is picked from the result of executing the code in the 3x2 block
19:09:01 <Hiato> well, kind of, you're close
19:09:17 <Hiato> what I meant was there are 6 commands, on a grid of 3x2
19:09:33 <Hiato> stuff happens in accordance with the currently selected command
19:09:46 <Hiato> the grid is just for visualisation of the wrap-around ness
19:10:10 <ehird`> i may need some thinking to understand this
19:10:19 <ehird`> it's kind of like full 0
19:10:34 <Hiato> amm.. no, not really
19:10:38 <Hiato> but yes, I suppose
19:10:46 <Hiato> in that there is a give allotment of commands
19:10:56 <ehird`> and the program has indirection
19:11:03 <Hiato> spread over some kind of shape (grid), and you select the command at will
19:11:09 <ehird`> i.e. it runs commands which select a command-2, and has an instruction to run the kind of command-2
19:11:30 <ehird`> oerjan: Scheme in Glass, sounds good
19:12:00 <Hiato> no, not really, It runs commands that select command 2, and then has an instruction to run the selected command, irrespective of what it is
19:12:25 <ehird`> oerjan: does glass have bignums?
19:19:10 -!- sebbu has joined.
19:21:00 <oklopol> i doubt the implementation has
19:22:23 <Hiato> http://rafb.net/p/2CJw0b73.txt
19:23:02 <Hiato> here it is, excuse the lame word-wrap, it was hand-done. Some things may be mis-aligned, I apologise as OO doesn't insert LF's if it wraps.
19:24:12 <ehird`> Glass is totally unhelpful on errors
19:25:56 <Hiato> Yip, they learnt from the best, the obscure, GHC! It's just a mild improvement on that... :P
19:26:29 <Hiato> for those who work for the NSA
19:26:30 <ehird`> but then you use delphi so you're used to NOT HAVING TO BE HARDCORE
19:26:41 <oerjan> rubbish. the industry-standard would at _least_ lock up the computer.
19:27:01 <ehird`> SimonRC: well, C++ was an elaborate joke...
19:27:11 <SimonRC> C++ can easily output multi-k error messages if you much up templates
19:27:23 <ehird`> why are you using templates
19:28:16 <ehird`> Push 1 if end of input, 0 otherwise.
19:28:16 <Hiato> ehird`, for your information, us delphi dudes may be soft on the inside, but nothing can ever penetrate k : Integer; k := 4 / 3; Error: "Uknown" type/class/object mismatch :P
19:28:21 <ehird`> i want it in the other way round
19:29:18 <ehird`> hm it seems like a 'not' in Glass would be non-trivial
19:29:53 <Hiato> ehird` : Are you writing an ACRONYM interpreter in Glass? (Sanity check)
19:30:12 <Hiato> just checking... :P
19:30:12 <ehird`> It will be able to run the Scheme ACRONYM interpreter, therefore ;P
19:30:19 <ehird`> It's going to be a restricted schem
19:30:23 <ehird`> -- no continuations methinks
19:30:41 <Hiato> sure, whatever floats your boat ;)
19:32:31 <ehird`> (_e)(_i)e.?<0>(_a)e.?=
19:32:38 <ehird`> if EOF, _e = 0, else _e = 1
19:32:58 <ehird`> the interpreter doesn't work.
19:33:02 <ehird`> it doesn't report EOF, for EOF.
19:33:41 <ehird`> http://www.complang.tuwien.ac.at/schani/oldstuff/index.html#schemeinunlambda
19:33:45 <ehird`> it's a compler, though
19:35:14 <ehird`> I should write that unlambda-abstraction-introducer, sometime
19:37:38 <Hiato> Hrmm.. does anyone know if GregorR will be peeved if I add my 1L_AOI spec to the wiki
19:38:00 <Hiato> because his is vague and incomplete, and is merely a suggestion for further investigation
19:38:46 -!- conal has joined.
19:38:55 -!- sebbu2 has quit (Connection timed out).
19:40:37 -!- MichaelRaskin_ has joined.
19:44:41 <Hiato> cool, then I'll put it up for the world to see :P
19:45:44 <ehird`> i think i'm going to type strictly algorithmically for a few minutes!
19:46:11 <Hiato> go for it, it'll be interesting (to say the least :P )
19:46:17 <ehird`> i shall handle nesting of quotes thus: "this quote is by el qwertybomb" and is terminated by the quotation marks.
19:46:26 <ehird`> i shall type entirely in lower-case.
19:46:37 <ehird`> i shall nest quotes by using ", then ', then `.
19:46:53 <ehird`> all smilies shall not count as closing parentheses (like this :)).
19:47:07 <ehird`> and closing marks must always be outside and after the nested pair.
19:48:15 <ehird`> if i break the rules, then i shall break the rules. deal with it.
19:48:21 <Hiato> how shalt thy express added information, such as (but not referring directly to) emotions and error messages and grammatical aids (such as the formidable question mark and ellipses) questionmark
19:48:47 <oklopol> i was just correcting that
19:48:50 -!- MichaelRaskin_ has left (?).
19:48:55 <ehird`> i shall handle all addressing of people with @name.
19:48:59 <ehird`> consider it a special directive.
19:49:05 <oklopol> oerjan: stop stealing my thoughts
19:49:08 <ehird`> case will not be preserved.
19:49:20 <ehird`> @hiato i am afraid i do not understand.
19:49:28 <Hiato> I present to you, your honour, a no contest plea
19:49:36 <oerjan> oklopol: i knew you would say that.
19:50:06 <ehird`> i cannot tell whether people are copying my style or not.
19:50:18 <ehird`> i seem to have become paranoid from my new logic typing!
19:50:28 <ehird`> oh no, a typing error.
19:50:41 <ehird`> i must devise a way to express replacements, yet regular expressions are ugly.
19:50:43 <Hiato> doth thou fail to comprehend the expressions put forth by my hand, to thine eyes, fellow interlocutor?
19:50:53 <oerjan> of course logic makes you paranoid. just look at Gdel.
19:51:01 <ehird`> ah! occurance-number"string"="string"
19:51:35 <ehird`> @oerjan gdel was infected by self-reference, which is why he became paranoid
19:51:37 <faxlore> regular expressions are ugly? :(
19:51:45 <ehird`> 1"paranoid"="paranoid."
19:52:57 <ehird`> @faxlore but i do, for they are quite hacky.
19:53:07 <oerjan> he doesn't mean it. he is just pretending in order to entrap us.
19:53:38 <oklopol> regular expressions are fairly erotic
19:53:56 <ehird`> they originated in the tradition of unix, also, which i feel in light of my style of typing for the present time ("the-right-thing" typing, so to speak) should be disowned in favour of the lisp way, or the mit way, or whatever you would like to call it.
19:54:56 <ehird`> i think what we need is a language like lojban, but that would work as a programming language.
19:55:01 <ehird`> more symbols, i guess. and less fluid grammar.
19:55:25 <ehird`> that would be cool (though i guess people have made lojban programming languages anyway, they are probably not usable in any sense (even in an esoteric way)).
19:55:31 * Hiato cannot get a word in without orejan or oklopol correcting him (emoticon)
19:55:33 <faxlore> lisp style namespaceing in s-expressions seems nice
19:55:47 <ehird`> @faxlore i do not understand.
19:55:50 <faxlore> although .. It's kind of hard to pronounce '(' and ')'
19:55:54 <Hiato> see, there you go :P
19:56:08 <oerjan> and i refuse to believe that was unintended :D
19:56:10 <ehird`> @faxlore ah, for a language. yes, i do not think s-expresisons are the best route for that :).
19:56:49 <oklopol> faxlore: do like in lalna, and use ´ and ` for nesting
19:57:21 <oklopol> (add five three) -> ádd five thrèe
19:57:32 <ehird`> "When the Nazi regime was briefly mentioned, Gdel informed the presiding judge that he had discovered a way in which a dictatorship could be legally installed in the United States, through a logical contradiction in the U.S. Constitution."[wikipedia] that is brilliant, i didn't know that :).
19:57:38 <ehird`> new syntax: "quote"[source].
19:58:17 <oklopol> i also used circumflex for infix
19:59:13 <oklopol> i recommend reading about the computer science geniuses, pretty much everyone had an interesting life
19:59:33 <oklopol> or then i've just been reading well-written books
19:59:46 <ehird`> it is ironic that gdel died from not eating for fear of being poisoned.
19:59:55 <ehird`> not much difference dying either way, i guess :P.
20:06:30 -!- Corun has joined.
20:12:10 <ehird`> hmm, my standard way to learn a language is writing a scheme interpreter. there's something wrong with that.
20:14:49 <Hiato> lol, :D Nope, can't quite put my finger on it ;)
20:20:51 -!- RedDak has joined.
20:29:37 -!- oerjan has quit ("Good night").
20:30:26 -!- ttm_ has joined.
20:30:48 -!- dbc has quit (Read error: 110 (Connection timed out)).
20:33:32 <Hiato> http://esoteric.voxelperfect.net/wiki/1L
20:38:52 <Hiato> Anyway, night everyone, it's late :(
20:38:56 -!- Hiato has quit ("Leaving.").
20:52:20 -!- conal has left (?).
20:55:01 <AnMaster> <ehird`> anyone have a favourite language they want a scheme in? :P <-- bash
21:20:45 -!- jix has quit ("CommandQ").
21:21:48 * ehird` is writing the spec for a rewriting term language thing.
21:24:59 <AnMaster> (then you did it in bash because someone coded a bashforth so...)
21:25:17 <ehird`> oklopol: as well as "A"->"B"
21:25:21 <ehird`> you can do expression->expresison
21:25:32 <ehird`> ("A"->"B")->("C"->"D")
21:25:42 <ehird`> and all terms rewriting "A" to "B" turn into ones rewriting "C" to "D"
21:26:03 <AnMaster> "^my (long|short) regex" -> "your \1 regex"
21:26:48 <oklopol> ah, one of my favorite concepts :)
21:27:12 <ehird`> input may come sometime
21:27:22 <oklopol> hmm, certain virtual trees are detected by a rewriting rule that kills them, and outputs?
21:27:36 <ehird`> oklopol: oh and i think i might make:
21:27:38 <ehird`> ("A"->"B")->("C"->"D")
21:27:41 <ehird`> first rewrite all As to Bs
21:27:49 <ehird`> ("B"->"B")->("C"->"D")
21:27:53 <ehird`> then, erwriting all Cs to Ds
21:27:54 <oklopol> a hard-coded rule ["output" object] -> outputs object
21:27:57 <ehird`> ("B"->"B")->("D"->"D")
21:28:06 <ehird`> then rewriting all ("B"->"B") to ("D"->"D")
21:28:23 <ehird`> oklopol: and "literals" on their own in a statement are outputted
21:28:40 <ehird`> oklopol: or should i have A->B a and b implicitly quoted..
21:28:42 <oklopol> i've done a similar thing for thue, but that's one sick idea
21:28:54 <ehird`> i mean, with my idea i think its computationally useless
21:29:08 <oklopol> i mean, that data and rewriting rules in the same package might have some interesting implications
21:29:30 <ehird`> i do think it makes it computationally unsuitable though
21:29:35 <ehird`> so, i'll make them quoted
21:29:49 <oklopol> well, if you do it like that, yes
21:29:54 <oklopol> yeah, quoting works for scheme
21:30:31 <oklopol> could you have metarules for those? :)
21:30:45 <ehird`> i'll just submit the 'basic' lang
21:33:13 <ehird`> oklopol: http://esoteric.voxelperfect.net/wiki/CRTL
21:33:23 <ehird`> feel free to comment, it's completely fluid right now
21:34:24 -!- ehird` has left (?).
21:34:28 -!- ehird` has joined.
21:34:35 <ehird`> better add the rule that strings are searched.
21:34:40 <ehird`> better add the rule that strings are searched.
21:34:42 <ehird`> better add the rule that strings are searched.
21:34:43 <ehird`> better add the rule that strings are searched.
21:34:46 <ehird`> better add the rule that strings are searched.
21:34:46 -!- ehird` has left (?).
21:34:48 -!- ehird` has joined.
21:34:50 <faxlore> better add the rule that strings are searched.
21:35:39 <oklopol> ("A"->"B")->("C"->"D") would be fine if you change it just a bit, 1. rules don't rewrite themselves 2. rules only rewrite rules of lesser degree
21:35:44 <ehird`> done, look now oklopol
21:35:57 <oklopol> this is a degree 2 rule, because it's l-side has a function
21:36:18 <ehird`> oklopol: lesser degree?
21:36:22 <ehird`> oklopol: OK refresh now
21:36:58 <ehird`> sounds like principa mathematica's hopeless Godel-avoiding
21:37:04 <oklopol> the degree is the most nested part of it or something
21:37:55 <ehird`> they hated self-reference and the paradox it entails
21:38:03 <ehird`> so sets of type N can only contain sets of type N-1
21:38:26 <oklopol> ah, well, that's a bit different
21:38:30 <ehird`> godel came up with godel numbering, showed how you could use it to construct a self-containing set and similar, and finally BAM godel's incompleteness theorem, you got yourself a paradox in principa mathematica
21:39:06 <faxlore> I think that Type : Type breaks for similar reasons
21:39:15 <faxlore> I really want to get the lambda term though
21:40:20 <ehird`> is CRTL1 (the current version) turing complete.
21:40:26 <ehird`> I think YES by isomorphism with thue?
21:42:50 <ehird`> oklopol: what about free variables
21:43:31 <ehird`> ("loop",x)->("loop",("loop",x))
21:43:42 <oklopol> that's the beauty of tree-rewriting
21:43:59 <oklopol> scoping is unbelievably sexy
21:44:22 <ehird`> since you only have "blah" and a->b
21:44:45 <ehird`> ("loop"->x)->("loop"->("loop"->x))
21:47:57 -!- CakeProphet has joined.
21:48:43 -!- GreaseMonkey has joined.
21:49:38 <ehird`> oklopol: updating the CRTL spec with free names now
21:50:53 <ehird`> oklopol: Oh, for useful stuff I need concatentation of strings.
21:53:38 <ehird`> OK, oklopol, new spec I think
21:53:44 <ehird`> http://esoteric.voxelperfect.net/wiki/CRTL
21:54:09 <ehird`> CakeProphet: you made dupdog? you might like this then, it's self-rewriting
21:54:20 <ehird`> I think it's turing complete.
21:55:10 <ehird`> CakeProphet: dupdog isn't turing complete, though
21:55:21 <ehird`> actually, you know what i'd like to see for this language?
21:55:23 <ehird`> a thue implementation of it
21:58:17 <ehird`> oklopol: should ("a"~"b")->c match "ab" or ("a"~"b")
21:58:32 <ehird`> ("abc"~rest)->(rest~"def")
21:58:38 <ehird`> then "abcblah" turns into "blahdef"
21:58:43 <oklopol> "a"~"b" should probably be "ab".
21:58:54 <ehird`> with free names allowed as you can see up there?
21:59:28 <ehird`> CakeProphet: highly inturingcomplete.
21:59:40 <ehird`> (Useless for anything but constant output, essentially.)
22:00:07 <oklopol> dupdog is interesting in that it's not interesting in anyway, but somehow seems cool :D
22:00:24 <oklopol> CakeProphet: check your memory
22:00:33 <CakeProphet> it's like... the most pointless thing ever.
22:00:41 <ehird`> CakeProphet: whatever the lowest class is :P
22:00:45 <ehird`> it can't do any real computation
22:00:50 <CakeProphet> no I mean... what computational class. We never figured that out.
22:00:54 <ehird`> http://esoteric.voxelperfect.net/wiki/CRTL#Examples
22:00:59 <ehird`> new program generating "barbar"! :P
22:01:04 <CakeProphet> I said it was FSA originally... but someone else said it wasn't.
22:01:07 <ehird`> CakeProphet: whatever the least powerful computational class is :P
22:01:29 <ehird`> it certainly can't represent all FSA
22:01:53 <ehird`> only a VERY restricted subset of them
22:02:11 <ehird`> now, someone implement crtl
22:02:27 <CakeProphet> an FSA isn't required... to represent multiple FSAs... that would be confusing and recursive.
22:04:23 <CakeProphet> a believe its a turing machines job to represent an infinite array of FSAs
22:05:22 <CakeProphet> the state of a dupdog program is... the source code itself.
22:05:29 <CakeProphet> it has an infinite number of possible states.
22:05:37 <CakeProphet> so it's not an FSA.... but it's nothing close to being a turing machine.
22:06:07 <CakeProphet> unless someone proves me wrong. Some mad genius could attempt to do it.
22:07:29 <CakeProphet> I'd say it's somewhere inbetween. Just don't know the name for it.
22:07:51 <ehird`> someone implement CRTL! :P
22:08:06 -!- ^_` has joined.
22:08:16 -!- GreaseMonkey has quit (Nick collision from services.).
22:08:25 -!- ^_` has changed nick to GreaseMonkey.
22:08:46 <CakeProphet> it has infinite states... but I don't think it can reach any of them arbitrarily. Its next state is dependent on its current state.
22:10:17 -!- immibis has joined.
22:10:30 <ehird`> Now someone implement CRTL! :P
22:11:37 <immibis> how do i change channels in irssi?
22:11:57 <CakeProphet> ...you want me to... implement CRTL in CRTL?
22:12:09 <ehird`> CakeProphet: Or, you know, any languge.
22:12:21 <ehird`> immibis: why not find out
22:12:22 <CakeProphet> oh. I thought you needed the first implementation
22:12:25 <ehird`> Er. That I have a compiler or interpreter for on here, obviously.
22:12:32 <CakeProphet> if one already exists... then I'm not doing anything.
22:12:39 <ehird`> it doesn't, CakeProphet.
22:12:52 <ehird`> But I could manually compile your interpreter into C or whatever and use that!
22:12:59 <CakeProphet> Alright. I'll implement it in Python. My practical language of choice.
22:13:02 <ehird`> Then we could call ourselves CRAZIER-LISP
22:13:56 <ehird`> i really want RETROLISP
22:14:01 <ehird`> which is like lisp of days of yore
22:14:07 <ehird`> and more fun for scripting
22:14:40 <ehird`> and you have a silly prompt, like " RETROLISP >> "
22:14:51 <ehird`> and it's written in both C and RETROLISP
22:15:16 <faxlore> go for about 50:50, where the language particular parts is written it.. totally arbitrary :D
22:15:34 <ehird`> well, you need the core and the parser in C :P
22:17:33 <CakeProphet> ...I don't understand the expression thing
22:17:46 <ehird`> CakeProphet: tree rewriting
22:17:57 <ehird`> if you don't understand it maybe you shouldn't implement it :)
22:18:07 <ehird`> oklopol! explain it to him
22:18:25 <ehird`> CakeProphet: terms in the program
22:18:37 <ehird`> you replace the whole expression
22:18:45 <CakeProphet> like thue... except I need this expression thing explained.
22:19:00 <ehird`> "find rules of the form (a->X) where X is of the form (b->c)"
22:19:57 <oklopol> ehird`: i see you have it going on pretty well
22:20:00 <ehird`> oklopol: I think he's having problems! :P
22:20:08 <ehird`> oklopol: But yeah, take a look at the new spec :D
22:20:19 <oklopol> unless that was a productive headscratch or something
22:20:21 <CakeProphet> give me an example of how that rule would change something else in the program.
22:21:14 <immibis> so (a->b)->(c->d) = replace a->b with c->d everywhere else?
22:21:35 <ehird`> immibis: yes, though that is an invalid rule if entered into a program
22:21:40 <ehird`> since 'c' and 'd' are free
22:22:02 <ehird`> CakeProphet: watch my dialog with immibis and i think it might become clear :P
22:22:39 <ehird`> in (a->b)->(c->d), 'a' and 'b' are bound, and 'c' and 'd' are free
22:22:56 <ehird`> in (a->b)->((c->d)->e), 'a', 'b', 'c', and 'd' are bound, and 'e' is free
22:23:16 <ehird`> free variables in a program are an error, no matter what
22:23:18 <oklopol> the left side is matched with the input, strings are just checked for matching, variables are set to whatever they correspond to in the input
22:23:30 <oklopol> variables are then substituted to the right side
22:23:35 <immibis> anything thats on the left side of an expression is bound, everything else is free?
22:23:37 <ehird`> oklopol: with scoping!
22:23:40 <oklopol> but, guess one explainer at a time :)
22:23:43 <ehird`> oklopol: you have to take into account a nested RHS
22:24:09 <ehird`> wait no you're right. (a->b)->((a->c)->c) should use the binding of 'a' from (a->b)
22:25:06 <ehird`> ... which makes this language effing awesome
22:25:09 <ehird`> updating the spec a-now
22:25:55 <ehird`> CRTL will become CRTL 1.0 unless anyone sees anything wrong with the updated spec
22:26:01 <faxlore> can you use this rewrite language as a theorem proer?
22:26:46 <oklopol> ehird`: do you have the degree rule?
22:27:46 <oklopol> i don't think there's any use for it with the rules don't change themselves rule
22:28:55 <ehird`> yeah no self-modifying rules because that would make programs infinitely more hard to write
22:29:04 <ehird`> oklopol: i think a fibonacci program might be good
22:31:05 <oklopol> increment: (("increment"->a)->("number"->(a->"a"))) decrement: (("decrement"->(a->"a"))->("number"->a))
22:31:34 <oklopol> nah, just done that many times
22:31:51 <ehird`> oklopol: you have to eliminate ("number"->a) at some point though
22:31:55 <ehird`> otherwise you'll have weird stuff
22:32:03 <oklopol> not really, in case you just never have "number" as such
22:32:15 <oklopol> that's what i was gonna ask earlier
22:32:26 <oklopol> can you rewrite *inside* another rule?
22:32:42 <oklopol> because that will screw up pretty much everything :)
22:33:28 <oklopol> ("foo"->"bar"); ("bar"->"foo")
22:33:36 <oklopol> do they rewrite inside the other rule?
22:34:07 <ehird`> i'll step through that program
22:34:14 <ehird`> "foo"->"bar"; "bar"->"foo"
22:34:37 <ehird`> (where epsilon is a null program)
22:34:42 <ehird`> oklopol: well what else should it do
22:35:47 <ehird`> it's a bit like a lambda calculus without scoping and all that :P
22:36:02 <oklopol> i have my reasons for loving tree rewriting
22:36:46 <ehird`> oklopol: you should totally implement this! :P
22:36:50 <oklopol> because tag->value is a common way to express "normal" tuples, tuples not meant as data
22:36:56 <oklopol> umm.. what because of that...
22:37:14 <ehird`> actually it's an amusing language in that it's 100% intuitive
22:37:22 <ehird`> the rewrite rules are very intuitive
22:37:28 <ehird`> the syntax, and semantisc
22:37:32 <oklopol> ah, i was just thinking perhaps that could be something like . instead of ->, since it's used for both rewriting and tuple creation
22:38:11 <oklopol> i've made a tree-rewriter once... i think i could just make a few changes to that
22:38:24 <oklopol> basically updating tuples into the rewriter tuple list
22:38:38 <oklopol> hmm... that might be a bit slow :-)
22:38:40 <ehird`> as long as it runs the example programs correctly!
22:38:47 <oklopol> not the simplest language to implement well
22:39:05 <ehird`> i really want to see an infinite-fibonacci program in the langugae though
22:39:18 <oklopol> i'm doing some scheming now, perhaps i can do it tomorrow
22:39:29 <oklopol> unless you can't resist doing it yourself today ;-)
22:39:38 <ehird`> the implementation or fibonacci
22:39:54 <oklopol> infinite... hmm, doesn't sound hard
22:41:10 <ehird`> in unary or whatever you want, no matter
22:41:16 <oklopol> actually, the rewriting scheme doesn't allow for a trivial implementation
22:41:17 <ehird`> note: for newline you will need to actually have a newline
22:41:26 <ehird`> how could i change it?
22:41:40 <oklopol> for you don't have guards, and you don't have definite evaluation order.
22:41:56 <ehird`> i do have definite evaluation order
22:45:29 <oklopol> you don't need it to be definite
22:45:59 <oklopol> fibonacci is easy enough, i'm just a bit headachey today
22:49:37 <oklopol> okay, i made a bunch of functions
22:49:41 <oklopol> then realized i don't need them :)
22:50:12 <oklopol> (("fib"->a)->b)->(("fib"->b)->a~b)
22:50:29 <ehird`> that does not output at every step of the way
22:50:33 <ehird`> and doesn't output with a newline
22:50:45 <ehird`> remember: you need "literal"; -- as one statement -- to output
22:50:51 <ehird`> so you need to have a dummy statement at the end
22:50:55 <ehird`> replace that witht he fibonacci rules
22:50:59 <ehird`> then calculate one step on a literal
22:51:14 <oklopol> how do i create a new statement?
22:51:26 <ehird`> replacing some kind of dummy literal
22:51:35 <oklopol> but... i'll need an infinite number of them?
22:51:45 <ehird`> i don't think you will
22:51:58 <oklopol> does the output thing vanish?
22:52:11 <ehird`> yes, should i change that
22:52:31 <oklopol> perhaps make it possible for a rule to produce multiple right sides
22:52:48 -!- RedDak has quit (Remote closed the connection).
22:52:51 <oklopol> (("fib"->a)->b)->(("fib"->b)->a~b);a
22:53:26 <oklopol> i forgot that was your original splitter
22:53:29 <oklopol> (("fib"->a)->b)->(("fib"->b)->a~b), a
22:53:48 <ehird`> i don't see how that would work
22:54:33 <oklopol> shouldn't that become (("fib"->"1")->"11"), then (("fib"->"11")->"111") etc.
22:55:09 <ehird`> that does nothing on its own
22:55:27 <ehird`> (("fib"->"1")->"1");("fib"->"1")
22:55:30 <ehird`> is a fancy way of saying "1"
22:55:47 <oklopol> why would that get applied to itself?
22:56:20 <ehird`> (("fib"->"1")->"1") is "replace ("fib"->"1") with 1"
22:56:24 <ehird`> apart from in the current rule
22:56:27 <ehird`> so it finds the next statement
22:56:44 <oklopol> where did you get that? :)
22:57:12 <oklopol> (("fib"->a)->b) -> (("fib"->b)->a~b), a <<< is the rule that's being applied
22:57:28 <oklopol> (("fib"->"1")->"1") will never be applied to anything.
22:57:55 <ehird`> it's ("fib"->"1")->"1"
22:57:59 <ehird`> (...) is just for grouping
22:58:15 <ehird`> (("fib"->"1")->"1") is
22:58:27 <oklopol> yes, but there's nothing it can apply to.
22:58:37 <oklopol> so it can be considered data.
22:58:51 <oklopol> just like a list in lisp is data even though you can apply it if you want.
22:59:13 <ehird`> well in a program it will have that effect.
22:59:37 <ehird`> faxlore: suggest a list quoting syntax for RETROLISP!
23:00:00 <ehird`> modern lisp: (QUOTE (A B C)) or '(A B C), LISP 1.5: ((A B C)), RETROLISP = ?
23:00:12 <oklopol> it's multiple right sides :)
23:00:14 <ehird`> a,b -> "replace with a then b"
23:00:30 <ehird`> ("foodle"->a)->something
23:00:36 <ehird`> what does that produce
23:00:49 <oklopol> the program "a" -> "b", "c"; "a" would print "b" and "c" if the function is applied, otherwise "a"
23:01:04 <faxlore> use , for quote and ` for unquote
23:01:05 <oklopol> both right sides are added to the tuplespace
23:01:30 <ehird`> oklopol: i'm sorry please look at my example
23:01:36 <ehird`> ("foodle"->a)->something
23:02:02 <oklopol> i'm looking, i guess you just couldn't use as data the functions that use ",".
23:02:35 <ehird`> there's no distinction
23:02:44 <ehird`> not data-and-function-calls
23:03:10 <ehird`> oklopol: but it's against CRTL philosophy
23:03:26 <oklopol> you can't match on something that isn't data, is the definition of not being data
23:03:29 <ehird`> faxlore: but "ABC" is strings :P
23:03:55 <ehird`> faxlore: naw, it mus thave parens somewhere
23:04:02 <ehird`> I just liked ((a b c)) in lisp 1.5
23:04:16 <faxlore> what is () being applied to?
23:04:43 <ehird`> old lisp was FUNNNNNNN for example did you know
23:04:53 <ehird`> started with an alice in wonderland quote
23:04:58 <ehird`> then had a text-only, no-symbols prompt
23:05:03 <ehird`> then it didn't even read s-expressions
23:05:21 <ehird`> to define the identity function you did
23:05:31 <ehird`> DEFINE ID ((LAMBDA (X) X))
23:05:37 <ehird`> to evaluate an s-expression you did
23:05:46 <ehird`> got another blank line
23:05:49 <ehird`> the lewis carroll quote
23:05:54 <ehird`> and the text-only prompt again
23:06:08 <ehird`> truly, an example of interface design!
23:06:29 -!- timotiis has quit ("leaving").
23:06:39 <ehird`> i just want a Lisp 1.5 for a modern machine
23:09:11 -!- CakeProphet_ has joined.
23:09:12 <ehird`> faxlore: don't you?!?!1!!!111
23:09:38 <faxlore> I want a lisp 9999999999999999999999999999999999999999999+1
23:10:04 <ehird`> I want LISP 1.5 for Modern x86 Architechtures, `libc' Version
23:11:30 <ehird`> faxlore: RETROLISP might be just as good, though
23:12:11 <faxlore> It must have lewis carrol quotes built in
23:12:24 <ehird`> yes, once every... i don't know, every hour or something
23:14:53 <faxlore> how about every call to apply?:D
23:17:00 <ehird`> faxlore: what about wariness to use symbols!
23:17:08 <ehird`> PLUS instead of + being used in all example code
23:17:49 -!- CakeProphet has quit (Nick collision from services.).
23:17:55 -!- CakeProphet_ has changed nick to CakeProphet.
23:19:09 <CakeProphet> my masterpiece-language-to-end-all-languages.
23:19:56 <ehird`> faxlore: see the prompts! http://b54.net/lisp15
23:20:00 <ehird`> CakeProphet: more example code.
23:22:46 <CakeProphet> I'm still working on... how it... determines order of operation.
23:25:16 <CakeProphet> the other problem is how it determines the end of a statement... or if it has a statement concept at all.
23:26:00 <ehird`> CakeProphet: left-to-right
23:26:06 <ehird`> pick one, i like right-to-left
23:26:16 <ehird`> end of statement: "abc. def."
23:26:37 <CakeProphet> like Python. Newlines unless there's an unclosed paren.
23:27:54 <CakeProphet> ...I'm trying to do it in one expression for awesome effect.
23:28:44 <ehird`> Integer$fib: self < 2 if: {<- self.} else: {<- ((self - 1) fib) + ((self - 2) fib).}.
23:29:15 <ehird`> String$sayWith:other: self say, other say.
23:31:46 <CakeProphet> ((#n = (n - 1) + (n - 2)) print) while True
23:32:33 <CakeProphet> if the mad scientist in me can pull off an implementation
23:33:08 <CakeProphet> it's going to be like... smalltalk mixed with lisp mixed with Python aesthetics mixed with some strange functional language.
23:34:01 <ehird`> 'some strange functional language'
23:34:23 <ehird`> faxlore: SETQ returns a variable reference
23:34:33 <ehird`> (INCF (SETQ A 2)) ; A = 3
23:35:02 <ehird`> INCF takes either a NAME, or a VAR-REF
23:35:36 <ehird`> (SETQ A 2) ; ==> #{VARIABLE REF 'A'}
23:35:50 <ehird`> (INCF (SETQ A 2)) ; ==> #{VARIABLE REF 'A'}
23:36:02 <ehird`> (SETQ (INCF (SETQ A 2)) "FOO") ; ==> #{VARIABLE REF 'A'}, and A = "FOO"
23:36:06 <faxlore> (INCF (INCF (INCF (INCF A))))
23:36:33 <ehird`> (REF (QUOTE A)) ; ==> #{VARIABLE REF 'A'}
23:36:36 <oklopol> CakeProphet: the fib looks interesting, can you give definite semantics?
23:36:43 <faxlore> (INCF (SETF (CDR (CONS 0 0)) 7)) ?
23:36:43 <oklopol> just for what you have there.
23:36:43 <ehird`> (SETQ (REF (QUOTE A)) 5) ; A = 5
23:36:52 <ehird`> faxlore: SETF is too modern. Doesn't exist!
23:36:55 <CakeProphet> oklopol, ...yes. But they're messy. I'd like it to be cleaner but with the same look and feel.
23:37:30 <ehird`> (REPLACD (CONS 0 0) 7) ; ==> #{CONS REF}
23:37:35 <ehird`> (INCF (REPLACD (CONS 0 0) 7)) ; ==> #{CONS REF}
23:38:16 <CakeProphet> ((#n = ((n - 1) + (n - 2))) print) while True
23:39:28 <ehird`> CakeProphet: support #a: 2
23:39:46 <ehird`> how? give everything a ":colon:" message.
23:40:10 <ehird`> #a blah: 2, when blah on #a is not a message, is #a blah :colon: 2
23:40:20 <CakeProphet> if you're familiar at all with smalltalk... you'll get the method calling part of the syntax. The difference here is the lack of colons and the use of only binary and unary methods.
23:42:05 <CakeProphet> and it's all lazy. Every parenthetical expression is frozen in an internal "block" object with its own methods
23:42:25 <CakeProphet> which explains why I can just put "while True" at the end of any expression and magically... make it go on forever.
23:43:26 <ehird`> sometime i want to make alanguage like haskell, but 'minimized'
23:43:46 <ehird`> you get funky type definitions, monads, pattern matching, laziness, etc., but just 'dumbed down' a bit
23:43:48 <ehird`> for learning about stuff
23:44:12 <ehird`> main = printNL "hello, world"
23:45:25 -!- CakeProphet_ has joined.
23:45:43 <ehird`> 23:43:23 <ehird`> sometime i want to make alanguage like haskell, but 'minimized'
23:45:43 <ehird`> 23:43:43 <ehird`> you get funky type definitions, monads, pattern matching, laziness, etc., but just 'dumbed down' a bit
23:45:43 <ehird`> 23:43:45 <ehird`> for learning about stuff
23:45:43 <ehird`> 23:43:57 <ehird`> main : io nil
23:45:43 <ehird`> 23:44:08 <ehird`> main = printNL "hello, world"
23:46:27 <ehird`> 23:42:22 <CakeProphet> which explains why I can just put "while True" at the end of any expression and magically... make it go on forever.
23:46:31 <faxlore> ehird`: What I'd really like is a good solid mixfix parser
23:46:39 <faxlore> ehird`: Then hook up various lambda calculus to it
23:47:11 <faxlore> I was going to use the Agda2 one.. but I don't think I can extract it without the whole thing falling to peices
23:47:35 <CakeProphet_> the (2 + 2) isn't evaluated... its saved as a function/block/unevaluated-dohicky/whatever.
23:47:48 <CakeProphet_> #x means "the symbol x"... as opposed to what x represents.
23:48:16 <CakeProphet_> so (2 + 2) never gets evaluated until you send it a message.
23:48:21 <ehird`> CakeProphet_: the term is 'thunk'
23:49:08 -!- immibis has left (?).
23:49:23 -!- sebbu has quit ("@+").
23:49:43 <CakeProphet_> it's basically a weird attempt to combine smalltalk logic and haskell laziness seamlessly.
23:53:20 <ehird`> so! we have APL-alikes, haskell-alikes and smalltalk-alikes
23:56:09 <ehird`> where ehirdtalk is infinitely superior.
23:58:03 <oklopol> shouldn't it be etalk if mine is oklotalk?
23:58:24 <oklopol> your real name is elliott hird, mine is oklofoan polakir
23:58:25 <ehird`> no, because mine has /more/ than oklotalk
23:58:38 <ehird`> and stop being stalkerish to the point of spelling my first name right
23:59:26 <ehird`> i have been called all 3
23:59:39 <ehird`> i have met one person with the exact same name as me
23:59:55 -!- CakeProphet__ has joined.