00:11:48 <lament> oerjan: if smetana+1 compacts the infinite smetana program to finite size, then it's obviously turing-complete
00:12:43 <lament> oerjan: the question is whether we can consider smetana to be turing-complete, despite infinitely large programs
00:14:11 <lament> and "smetana+1 is just a notation" would be a good argument for that.
00:15:15 <ehird`> if it is turing complete
00:15:19 <ehird`> it can hardly be said to be just a notation
00:15:59 <lament> ehird`: that doesn't make any sense.
00:20:49 <pikhq> ehird`: Any more pebble.bfm insanity?
00:20:55 <ehird`> pikhq: damnit!!! i forgot
00:21:18 <ehird`> pikhq: it'll also be harder than i thought due to lack of strings in pebble
00:21:37 <pikhq> Meaning that you'd have to do string functions first.
00:21:56 <ehird`> the hardest part would be coming up with an efficient representation
00:22:16 <ehird`> i mean, H1e1l1l1o1w1o1r1l1d is... bigger than neccessary
00:24:30 <lament> Only by a constant factor.
00:24:43 <pikhq> And "Hello world\0x00" is. . . Not useful for string insertion in Brainfuck. ;)
00:25:51 <ehird`> i guess, i'll do the swapping-algorithm
00:25:55 -!- jix has quit ("This computer has gone to sleep").
00:26:15 <ehird`> make 0 the index of the string from the end you want to access
00:26:19 <ehird`> swap and -1 repeatedly
00:26:43 <ehird`> just go from H until you find 0
00:27:57 <ehird`> though the swapping could be inefficient
00:29:18 <ehird`> pikhq: lament: comments?
00:29:41 <lament> i bought sheet music paper!
00:30:33 <lament> 10 staves per sheet, 40 sheets (related to my previous comment)
00:31:00 <ehird`> related to my algorithm
00:36:57 <ehird`> i guess the swapping would be slow
00:40:03 -!- RedDak has quit (Read error: 113 (No route to host)).
00:51:15 <ehird`> no/yes? ;) (lament,pikhq)
00:55:59 <ihope> Are you looking for minimal Turing-complete systems?
00:59:25 * ihope creates a parser called convertNewZealand
00:59:55 <ihope> It converts from unary to decimal with New Zealand.
00:59:57 <ehird`> is the unary->anything converter actually possible/easy in your subst lang?
01:00:03 <ihope> It's certainly possible.
01:00:18 <ehird`> so how does it utilize new zealand
01:00:40 <ihope> By New including a Zealand if the string is "".
01:00:57 <ihope> ...including New Zealand, I mean.
01:01:23 <ehird`> so what is a New Zealand
01:01:40 <ihope> A backronym for "no zero".
01:01:57 <ihope> And now for another regex mnemonic: "Look up there! It's money!"
01:02:22 <ehird`> (By the way, what regexps do you use? Custom?)
01:02:24 <ihope> "" is converted to "" instead of "0".
01:02:30 <ihope> Undefined, really.
01:02:43 <ihope> Though $ is a pretty important part of it.
01:04:21 <ehird`> Does your language have a way of putting anything to the screen?
01:04:35 <ehird`> A primitive or something, that does no substitutions, but has a side effect of output
01:04:44 <ihope> It could easily be extended to include one.
01:05:32 <ehird`> Because you could make a program basically identical to fibonacci.b
01:05:41 <ihope> bleach(): {/[ab]/; "w" + bleach()}
01:05:42 <ehird`> Writes out fibonacci numbers in decimal, one per line, until halted.
01:05:51 <ihope> (With an invisible period on the end.)
01:05:58 <ehird`> ihope: what does that do?
01:06:07 <ihope> It replaces a and b with w.
01:06:22 <ihope> ...and gives an error when it reaches the end of the string.
01:06:46 <ihope> It was going to make input more friendly for convertNoZero, but I just realized it's actually completely unnecessary.
01:07:08 <ehird`> Just match . instead of w :-)
01:07:31 <ihope> Well, I was thinking [ab].
01:07:47 <ehird`> You want it to be generalized
01:08:05 <ehird`> since unary is just a way of encoding a string as its length, the actual contents is arbitary
01:10:06 * ihope decides to go for little-endian increment
01:10:29 <ehird`> So what is your language called?
01:11:11 <ihope> No implementation. I think I'll call it Redivider.
01:11:26 <ehird`> It's really interesting, I might implement it :)
01:11:44 <ihope> Should I finish the program or the spec first?
01:11:45 <ehird`> Does it have a spec or similar? I mean, defining regexps beyond the basics could be hard...
01:16:13 <ihope> Is it okay if I use the word "guts" in the spec? :-P
01:16:31 <ihope> As in <regex> ::= "/" <regexguts> "/"
01:16:35 <ehird`> But I want to see the program first!
01:16:40 <ehird`> as long as you define regexguts
01:16:42 <ihope> Yes, I'm still doing that.
01:16:49 <ihope> Pff, why would I do that? :-)
01:17:01 <ehird`> because otherwise i won't implement it, having no spec :P
01:17:08 <ehird`> i'm not going to use a third-party regexp spec
01:17:14 <ehird`> that'd be inconsistant with other implementations!
01:17:19 <ihope> I'll write my own minimalistic one, then.
01:17:22 <ehird`> think of all the regexp libs... you gotta define your own for portability ;)
01:17:28 <ehird`> just give it enough to be comfy for use
01:17:41 <ihope> Ranges, exclusion...
01:17:51 <ihope> Plus /[]/, the regex that doesn't match.
01:17:53 <ehird`> there's not much to regexps
01:18:21 <ehird`> i doubt it, personally, but..
01:18:34 <ehird`> I might try and write a bf interp in it. :)
01:18:46 <ihope> Redivider is almost certainly TC.
01:18:48 <ehird`> hm, i think that would be possible
01:18:55 <ihope> If http://pastebin.ca/679421 has no bugs, it is.
01:19:11 <ehird`> But brainfuck = far more fun
01:19:46 <ehird`> very crazy suggestion for regexps
01:20:08 <ehird`> <x> means "anything function x matches"
01:20:20 <ehird`> this would make, e.g. parsing brainfuck braces trivial
01:20:24 <ihope> That sounds rather complicating.
01:20:25 <ehird`> though perhaps it's too bloated in your mind ;)
01:20:35 <ehird`> i don't know, it'd just make a lot of stuff you could think of easier
01:20:49 <ihope> This language is inspired by Parsec, which is a completely ordinary combinator parser as far as I can tell :-)
01:21:28 <ehird`> Well, yeah, but with parsec you could insert random haskell in the middle
01:21:33 <ehird`> Something like (i don't know haskell)
01:21:44 <ehird`> match "abc" ++ callParser ++ match "def"
01:21:48 <ehird`> with these regexps, you can't
01:22:02 <ihope> I think you can still do that here.
01:22:32 <ihope> /abc/ + parser() + /def/ will work and return "abcwhatevertheparserreturneddef".
01:23:11 <ihope> First it runs /abc/, which consumes the abc and returns "abc", then it runs parser(), which consumes something and returns something, then it runs /def/, which consumes the def and returns "def".
01:23:46 <ihope> If bf() parses "foo" into "bar", that'll parse "[foo]" into "[bar]".
01:24:23 <ihope> If you don't like the brackets around it, then there's {/[/; x <- bf(); /]/; x}
01:24:35 <ehird`> what is a function that parses nested parens with anything in
01:24:36 <ihope> That parses "[foo]" into "bar".
01:24:53 <ehird`> (abc) ((ab)c) (a(b)(c((d)))) parses, (a etc don't
01:25:05 <ehird`> More importantly: some way to get the inner contents
01:25:22 <ehird`> but, of course, ONLY if the whole thing has well-formed braces
01:25:26 <ihope> What does (ab)c return?
01:25:32 <ihope> Possible, yes. Probably easy, too.
01:25:37 <ehird`> i guess that's undefined
01:25:52 <ehird`> i just mean, if you can do that, then you can parse brainfuck
01:26:13 <ihope> check(): /(/ + check() + /)/ + check() | /[^()]/ + check()
01:26:16 <ehird`> if you have "code[SENTINEL]tape", then you can run a brainfuck program trivially, iirc
01:26:19 <ihope> ...with that invisible period.
01:26:28 <ihope> That just checks for well-formedness.
01:27:08 <ihope> grab(): {/(/; x <- check(); /)/; x}
01:27:17 <ihope> ...period again, gah.
01:27:21 <ehird`> So what are these "x"s etc?
01:27:28 <ehird`> Just arbitary variables that are "" by default?
01:27:36 <ihope> By default, they're errors.
01:27:46 <ehird`> So how does grab(): {/(/; x <- check(); /)/; x} work
01:27:48 <ihope> They always hold strings, never parsers.
01:28:23 <ihope> It runs /(/ and throws away the result, then runs check() and stores the result in x, then runs /)/ and throws away the result, then runs x and returns the result.
01:28:31 <ihope> A string is the same thing as a parser that does nothing and returns that string.
01:28:43 <ihope> x is a local variable, I guess.
01:28:55 <ihope> x <- check() is what introduces it.
01:29:15 <ihope> Or creates or some such.
01:29:21 <oerjan> <- is obviously borrowed from haskell's do notation
01:29:32 <ihope> I guess you can do it that way. You might as well do z <- x + y, though.
01:29:49 <ihope> These behave pretty much exactly the same way as in Haskell's do notation, yeah.
01:29:56 <ehird`> Why, ihope? Why have unneeded vars?
01:30:20 <ihope> Less confusion, I guess, if you find that sort of thing confusing.
01:31:53 <ihope> I think this is right, apart from the fact that it outputs the numbers all smooshed together if output doesn't automatically add a newline: http://pastebin.ca/755940
01:32:43 <ehird`> is main a special name? or is it just what you called it as a convention? and, what's []?
01:33:03 <ihope> There's not necessarily anything special about it.
01:33:24 <ihope> foo()[blah] makes foo parse blah; otherwise, it parses from whatever it's called in.
01:33:32 <ehird`> Could you like put it in the spec? "If there is a main function, it is called at runtime, otherwise you are dropped in to a REPL?"
01:33:39 <ihope> The "current string", I guess.
01:33:48 <ehird`> foo()[blah]... why not just foo(blah)?
01:33:53 <ehird`> I can't see the ()s being used for anything else there
01:34:13 <ehird`> Plus it would look nicer.
01:34:41 <ihope> They're for when you want parsers to take parameters other than the current string.
01:35:13 <ehird`> If so, may I humbly suggest just foo(str, extra)?
01:35:37 <ihope> Though I rather feel foo(extra, str) would be better.
01:35:46 <ehird`> Although... What if you want extra args, but default string?
01:35:54 <ehird`> Maybe some kind of seperator
01:36:05 <ehird`> no, no... that won't work nicely
01:36:22 <ihope> Extra arguments but the default string would just be foo(extra).
01:36:37 <ehird`> How can it tell the difference between foo(str) and foo(extra)?
01:37:04 <ihope> Each parser has a parameter number. If it's given that many parameters, then they're all actually parameters; if it's given one more, the last one is the input string.
01:37:28 <ehird`> Parser with 1 parameter number:
01:37:34 <ehird`> I just want to pass it a special string.
01:38:03 <ihope> If foo's parameter number is 1, then str is the parameter.
01:38:16 <ehird`> Right! BUt I don't want it to be.
01:38:21 <ihope> If foo's parameter number is 0, then str is the input string.
01:38:24 <ehird`> I just want to pass it an extra string, with no extra parameters.
01:38:29 <ehird`> Foo's parameter number is 1.
01:38:41 <ihope> If foo's parameter number is 1, then use foo(parameter, inputstring).
01:38:49 <ehird`> I don't want to give it an extra parameter
01:39:03 <ihope> If foo's parameter number is 1, it must take a parameter.
01:39:12 <ehird`> No optional parameters
01:39:46 <ihope> If you like those optional parameters, go the Haskell Way and use foo("J" + parameter) or foo("N") :-)
01:39:47 <ehird`> I suggest making inputstring the first
01:40:02 <ehird`> It feels like it's what the parser is being called /with/
01:40:06 <ehird`> Everything else is just additional info
01:40:25 <ihope> I sort of have the opposite opinion for the same reason.
01:40:28 <ehird`> For increasing parameter num: foo(str), foo(str,1), foo(str,1,2) etc
01:40:41 <ehird`> str - the main part of the parser, it's what its actually parsing - moves, in your smantics
01:41:19 <ihope> Well, if parameter numbers can vary, you need some way of differentiating a parameter from an input string.
01:41:32 <ehird`> First parameter: string
01:41:38 <ehird`> Rest: parameters, function dependena
01:42:21 <ehird`> The string is there regardless of the function
01:42:25 <ehird`> The rest is stuff added on "after the tail"
01:42:36 <ihope> The input string's being optional is sort of necessary.
01:42:36 <ehird`> It makes so much more sense for the string to be first.
01:43:27 <ihope> You need some way of making reference to the current string... or maybe this could be done without the current string stuff? Hmm.
01:43:47 <ehird`> func() # current string
01:44:04 <ehird`> you can call a function with a parameter
01:44:06 <ehird`> but with the current string
01:44:10 <ehird`> OK, you're right, yours is better
01:44:32 <ehird`> [abc] means "abc as string argument"
01:44:38 <ehird`> and can be anywhere, but is generally at the start
01:44:46 <ehird`> for a function with parameter value 2:
01:44:53 <ehird`> func([str], 1, 2) # using str
01:45:07 <ihope> How would varying numbers of parameters work, anyway?
01:45:15 <ehird`> I'm not talkng about that
01:45:22 <ehird`> func(1,2) and func(1,[str],2) would work
01:45:28 <ehird`> i.e. [] just mean "string argument"
01:45:34 <ihope> Seems a little pointless.
01:45:34 <ehird`> func2(str) # I guess, for parameter value 0, the []s would be optional, for nicety
01:45:52 <ehird`> so, progression: func(str) func([str],1) func([str],1,2)...
01:46:09 <ehird`> ihope: Well, it's nicer than allowing one additional argument. Think of the bugs - it's just not obvious at a glance
01:46:41 <ehird`> I think it's nicer, IMO
01:46:45 <ihope> Well, the input string is quite a bit like just another parameter.
01:47:06 <ehird`> func(1,2,oops-an-additional-arg)
01:47:11 <ehird`> That could so easily be a bug.
01:47:15 <ehird`> And explicitness is better, I'd say
01:47:29 <ehird`> func(1,2,oops) would be an error - "too many arguments, perhaps you need []?"
01:47:38 <ehird`> func(1,2,[oops]) would do what you intend
01:47:43 <ihope> Though I like the look of semicolons better.
01:47:51 <ehird`> (Probably [] would by convention go at the start, though - func([oops], 1, 2))
01:47:56 <ihope> func(1, 2, oops;) and func(1; 2, oops) and such.
01:47:57 <ehird`> So, I think that'd be good.
01:48:03 <ehird`> but [oops] at the start or end by convention?
01:48:11 <ehird`> ihope: Well, it just seems not noticable enough to me
01:48:40 <ihope> "It's an esoteric language; get over it"? :-P
01:48:51 <ehird`> Esoteric language != unplanned language
01:49:02 <ehird`> I think that [] here makes more sense
01:49:20 <ihope> How about func(1, 2; oops] and func[oops; 1, 2)?
01:49:23 <ehird`> Instead of func()[blah]
01:49:55 <ehird`> func[blah] would be sugar for func[blah](), since the former looks nicer
01:50:09 <ehird`> Though maybe func[blah]() would be nicer, as its more consistant - func[blah] is the parser that matches on blah
01:50:42 <ihope> Well, there are no first-class parsers here.
01:50:46 <ehird`> output[reverse[unary()]] output[reverse[unary()]()]()
01:50:49 <ehird`> The former is definately nicer
01:51:05 <ehird`> a() is a[current_str]()
01:51:07 <ihope> Hey, maybe we could get rid of () entirely.
01:51:12 <ihope> I mean, make it optional.
01:51:14 <ehird`> a[b](c,d) is what you expect
01:51:36 <ehird`> I think the above is probably the best
01:51:40 <ihope> I mean just (), not (stuff).
01:51:49 <ihope> No foo(); just foo.
01:51:49 <ehird`> run(): {x <- step(); output()[reverse()[unary()]]; run()[x]}.
01:51:56 <ihope> output[reverse[unary]]
01:51:57 <ehird`> run(): {x <- step(); output[reverse[unary()]]; run[x]}.
01:52:08 <ehird`> ihope: I think in that case () provides more information
01:52:17 <ehird`> You could mistake it for a variable.
01:52:36 <ehird`> I'll rewrite your paste using that proposed syntax
01:53:04 <ehird`> http://pastebin.ca/755956
01:53:10 <ehird`> IMO, it looks really clean and easy to understand. Very nice.
01:53:36 <ehird`> Likewise, func[a](b,c) follows naturally from that syntax.
01:53:38 <ihope> Yes, you're right.
01:53:49 <ehird`> So, can I expect a spec tomorrow maybe? ;)
01:53:59 <ehird`> Very interesting langugae
01:54:05 <ehird`> It's esoteric but looks really easy to program in too
01:54:16 <ehird`> OK. Leave me a memo with MemoServ if you get it done :)
01:55:20 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
04:25:58 -!- tokigun has joined.
04:51:12 <GregorR> THIN FUNCTIONS WILL BE THE DEATH OF ME
04:52:52 <oerjan> GAUNT ZOMBIE FUNCTIONS, LOOKING FOR BRAINS...
04:56:22 <GregorR> Unfortunately, I believe that the solution is to abandon my dictum that all blocks are functions :(
04:56:50 <pikhq> You *could* do it as Tcl does. . .
04:57:08 <pikhq> Provide an "uplevel" command, which executes something up a level in the stack.
04:57:21 -!- ihope has quit (Read error: 110 (Connection timed out)).
04:58:19 <oerjan> that's not very higher-order. a function should not necessarily know where it was called.
04:58:23 <pikhq> I guess it's not Plofy, though.
04:58:28 <GregorR> Mind you, it's better than thick and thin :P
04:59:52 <pikhq> But not much better.
05:01:51 <oerjan> hm... isn't a thick function essentially one that binds its escape continuation to return?
05:19:05 <GregorR> That's a truly bizarre way of looking at it :P
05:19:46 <GregorR> A thick function is the point in the call stack that a return will drop do.
05:33:48 <oerjan> alternately, a thick function is one which catches the return exception. you could generalize that.
05:34:03 -!- oerjan has quit ("leaving").
05:34:38 <GregorR> Oooh, that's a good way to think about it.
05:34:43 <GregorR> Returns become throws with special syntax.
05:35:01 <GregorR> Thick functions are just functions with implicit try/catch blocks.
05:35:18 <GregorR> Now, how can I use that to get rid of thick functions :P
06:58:56 -!- staplegun_ has joined.
06:59:47 -!- staplegun_ has changed nick to i4nic8.
07:03:24 -!- i4nic8 has quit (Client Quit).
07:03:44 -!- i4nic8 has joined.
07:17:54 -!- i4nic8 has quit ("ChatZilla 0.9.78.1 [Firefox 2.0.0.8/2007100816]").
07:26:42 -!- puzzlet has quit (Remote closed the connection).
07:26:50 -!- puzzlet has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
10:26:33 -!- puzzlet has quit (Remote closed the connection).
10:26:37 -!- puzzlet has joined.
10:32:34 -!- puzzlet has quit (Remote closed the connection).
10:32:40 -!- puzzlet has joined.
11:09:34 -!- bsmntbom1dood has joined.
11:21:20 -!- bsmntbombdood has quit (Read error: 110 (Connection timed out)).
11:49:14 -!- jix has joined.
11:49:24 -!- jix has quit (Remote closed the connection).
11:49:51 -!- jix has joined.
12:37:45 -!- Tritonio has joined.
13:56:49 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
13:58:26 -!- puzzlet has joined.
15:08:29 -!- ehird` has joined.
15:12:55 <ehird`> GregorR: that try/catch idea for thick functions is good but it doesn't help you vanquish thick/thin functions
15:13:25 <GregorR> Hence, "<GregorR> Now, how can I use that to get rid of thick functions :P"
15:13:59 <ehird`> in fact it probably complicates it
15:14:07 <ehird`> because you introduce syntactic sugar etc and even more thick/thin semantics
15:14:28 <ehird`> ok, show me a recursive factorial again so i can see thick vs thin and i'll try and figure out a way to resolve it
15:16:24 <GregorR> http://www.pastebin.ca/756432
15:23:32 <oklopol> GregorR: make it always run the program with every single combination of thick and thin functions at the same time, and introduce another, declarative, language, you have to use with the actual plof code to tell the interpreter what the correct behavior is; it can then resolve the right combination of thick/thin functions automatically
15:34:55 -!- Tritonio has quit (Read error: 110 (Connection timed out)).
15:36:16 <ehird`> pikhq: pebble.bfm will be called Calculus ;) I'm working on it no
15:36:20 -!- Tritonio has joined.
15:48:44 -!- bsmntbombdood has joined.
15:48:55 -!- oerjan has joined.
15:57:39 <ehird`> pikhq: how does eval work? does it run at compile-time?
16:00:02 -!- bsmntbom1dood has quit (Read error: 110 (Connection timed out)).
16:24:49 <ehird`> If {} is seen in the context of an assignment
16:25:03 <ehird`> You still have thick/thin, but it's internal only.
16:25:05 <GregorR> The first argument to 'if' is thick.
16:25:14 <ehird`> it does not need to be, though.
16:25:26 <GregorR> Yes it does, it returns a value that 'if' needs to catch.
16:25:44 <ehird`> Yeah, but {value} works
16:25:47 <ehird`> You don't need to use "return"
16:25:50 <ehird`> RodgerTheGreat: plof is not new
16:26:08 <ehird`> RodgerTheGreat: there is a new language though!
16:26:22 <GregorR> ehird`: Well, in Plof2, returning and evaluating to a value are identical, but I suppose that doesn't need to be the case :)
16:26:35 <GregorR> So, lemme mull over cases where that might be wrong.
16:26:49 <ehird`> GregorR: return will zoop down the stack, but a value at the end will just evaluate to it.
16:27:11 <GregorR> "zoop" being of course the technical term.
16:27:17 <ehird`> RodgerTheGreat: It's ihope's. It's called Redivide, and it's a turing complete substitution language. Fibonacci numbers: http://pastebin.ca/755956
16:27:48 <ehird`> http://pastebin.ca/679421 SK calculus implementation
16:27:57 <ehird`> that syntax is the old version
16:28:03 <ehird`> I'l update it (the SK calculus one)
16:28:24 <ehird`> http://pastebin.ca/756513 new SK calculus
16:28:50 <ehird`> [x] means "parse string x", it defaults to the current string if not speciified
16:29:01 <ehird`> you can also pass extra parameters (if defined in the function) with (a,b...)
16:29:08 <ehird`> but, you cannot omit both [] and ()
16:29:35 <ehird`> so, parser() for no arguments, parser(a) for one argument, etc. or with a different string: parser[str] (note no () - it looks nicer), parser[str](a), parser[str](a,b) etc
16:29:48 <ehird`> apart from that, the rest is pretty self-evident I think
16:30:30 <ehird`> main(), of course, is run with an empty string by default if it's there, when interpreting/running the compiled version
16:30:34 <ehird`> if it's not there, it drops into a REPL.
16:30:42 <ehird`> A full spec is being written by ihope, it should be ready sometime today
16:30:46 <ehird`> But I thik it's very interesting.
16:58:32 -!- bsmntbombdood has quit (Read error: 110 (Connection timed out)).
17:11:34 -!- jix has quit ("CommandQ").
17:15:19 -!- jix has joined.
17:26:56 -!- jix has quit (Nick collision from services.).
17:27:06 -!- jix has joined.
18:03:05 -!- jix has quit ("CommandQ").
18:09:09 -!- jix has joined.
18:58:49 -!- RedDak has joined.
19:33:29 -!- oerjan has quit ("leaving").
20:07:19 -!- sebbu2 has joined.
20:27:19 -!- sebbu has quit (Connection timed out).
20:37:26 -!- Tritonio_ has joined.
20:37:33 -!- Tritonio has quit (Read error: 110 (Connection timed out)).
21:40:58 -!- bsmntbombdood has joined.
21:42:18 -!- sebbu2 has changed nick to sebbu.
21:44:16 -!- ehird` has quit ("Leaving.").
21:45:45 -!- ehird` has joined.
22:00:37 -!- ihope has joined.
22:03:25 -!- ihope has quit (Client Quit).
22:12:33 -!- ihope has joined.
22:16:40 <ehird`> any work on the redivide spec? :)
22:17:46 <ihope> I'm still working on it.
22:18:00 <ehird`> RodgerTheGreat said that redivide was interesting earlier today :P
22:19:14 <ehird`> output[str] gets away from non-purity by saying "Does no substitutions. (In an interactive interpreter, this is printed as debug output)" sneakily,
22:19:17 <oklopol> hah, i said it was interested before it was famous!
22:19:20 <ehird`> but what about input()?
22:19:35 <ehird`> oklopol: I was interested in it when ihope first mentioned it ages ago
22:19:38 <ehird`> I just didn't mention it at the time :P
22:20:07 <ihope> ehird`: can't input() be the same way as output()?
22:20:24 <ehird`> ihope: Well, no, because it has to return the string from input.
22:20:41 <ehird`> ihope: You can't get away from non-purity there, unlike my above output[] definition
22:21:02 <ihope> Who cares about purity? :-P
22:21:12 <ihope> Evaluation order already matters.
22:21:18 <ehird`> Well, if it's a substitution language it's expected that you know what's happening to the program :P
22:21:37 <ehird`> You know what I mean? It's like a list of rules... putting non-purity in there (that isn't carefully worded) could damage that
22:22:23 <ihope> I still don't think there's much of a problem if evaluation order already matters.
22:25:00 <oklopol> ihope: please add thread support <3
22:25:30 <ehird`> ihope: you should at least allow multi threading
22:25:43 <ehird`> so an implementation can run it concurrently! :D
22:25:50 <ihope> In a way that doesn't affect semantics, you mean?
22:25:53 <oklopol> hmm, how exactly would that be possible :P
22:26:22 <oklopol> the fastest parser gets the string!
22:26:40 <ihope> Evaluate bar() and baz() simultaneously if possible.
22:27:21 <oklopol> hmm, it's pretty hard to evaluate two parsers simultaneously unless you know how much they'll gorge already
22:28:42 <ehird`> since there's no first-class parsers there's another easy thing
22:28:45 <ehird`> forbid it if IO is done
22:29:02 <ehird`> (no first class parsers = you can just check for output/input in them)
22:34:02 <ihope> Hmm. Is it okay if .|*()[ are the only special characters outside brackets and \^-] the only special characters inside brackets for regexes?
22:34:37 <ehird`> You need \ everywhere, though
22:34:42 <ehird`> if you can't escape something in any place, fix that
22:35:09 <ihope> ...er, yes, \ outside brackets as well.
22:35:51 <ihope> Now lemme take 37.5 moments to reboot.
22:37:15 -!- ihope has quit (Read error: 104 (Connection reset by peer)).
22:38:42 -!- oerjan has joined.
22:39:51 <GregorR> 37.5 moments = 56.25 minutes
22:39:57 <GregorR> Apparently it takes ihope nearly an hour to reboot.
22:40:13 <ehird`> (9:46:17 PM) ihope: Now lemme take 37.5 moments to reboot.
22:40:16 <ehird`> (9:50:17 PM) GregorR: 37.5 moments = 56.25 minutes
22:40:26 <ehird`> that's not nearly an hour
22:40:59 <oerjan> he may have meant moment in the sense of rotation physics. maybe he passed out from it.
22:41:20 <GregorR> ehird`: How is 56.25 minutes not nearly an hour?
22:41:24 <GregorR> It's only 3.75 minutes short
22:41:38 <ehird`> GregorR: ... ihope said blah blah reboot at 9:46
22:42:22 <ehird`> yes but it has not been nearly an hour
22:42:44 <GregorR> "Moment" used to be a defined unit of time measurement being 1.5 minutes.
22:42:48 <GregorR> 37.5 moments = 56.25 minutes
22:48:30 -!- ihope has joined.
22:48:36 <ihope> Okay, so maybe that was actually 387.98 moments.
22:48:58 <ihope> That's slow even for my Windows machine.
22:48:58 <bartw> GregorR: defines a moment as about 1.5 minutes
22:50:05 <ihope> You calculate how many moments that actually was.
22:51:57 <GregorR> From now on, I will assume that all users choose their nickname in the same way that I do.
22:52:14 <GregorR> e.g. Ihop Erickson and Ehird `-$*@/\\\
22:52:58 <ehird`> Actually my nick is ehird
22:53:03 <ehird`> ehird` is just because ehird got stolen :(
22:53:14 <GregorR> Well, then Ehir Dickinson :P
22:53:18 <GregorR> At least make it a last name ;)
22:53:25 <oerjan> ehird`'s real name is not particularly secret
22:53:26 <ihope> Erickson and Dickinson?
22:53:27 <GregorR> (Which apparently means ending it with "son")
22:53:45 <ehird`> oerjan: how come? i haven't told anyone in here it, i don't think...
22:53:49 <ehird`> (it's Elliott Hird anyway)
22:53:58 <ihope> What's your obsession with ck and son?
22:54:09 -!- ihope has changed nick to IhopE.
22:54:49 -!- ehird` has changed nick to ehirD.
22:54:52 -!- ehirD has changed nick to EhirD.
22:55:13 -!- EhirD has changed nick to EhirD`.
22:55:25 <EhirD`> oerjan: so how is it not particularly secret? :P
22:55:33 <IhopE> Maybe it's Ehir Donald `-$*@/\\\.
22:55:42 <oerjan> EhirD`: well i did know it didn't i?
22:56:10 <EhirD`> oerjan: i think so, but how? :P
22:56:12 <EhirD`> it's not in my whois atm
22:56:40 <IhopE> Your name is purple?
22:57:16 <EhirD`> GregorR: So what is RodgerTheGreat's name?
22:58:21 <EhirD`> Rodger Therrickson Handlebrock Entrepreneur Gullible Russell Ensonava Aeota Therrickson?
22:58:50 <GregorR> "Gullible" = awesome name :P
22:59:01 <EhirD`> "Wow. My name isn't in the dictionary"
22:59:15 <GregorR> "What's your name?" "Gullible." "Really? Wow!" "No, gotcha bitch!"
22:59:24 <EhirD`> "...actually, yes it is."
22:59:29 <oerjan> EhirD`: hm, you actually don't have a presence on the esolangs wiki?
22:59:39 <oerjan> thought that might have been it
22:59:43 <IhopE> Rodger Thomas Harry Elliot Graetz-Russell-Erickson-Aritz-Thomson!
22:59:58 <GregorR> I'm totally renaming myself Gregor Van Von O'McFitzsonovichstein
23:00:06 <RodgerTheGreat> believe it or not, my name in real life *isn't even Rodger!*
23:00:36 <IhopE> Or Rodger Tokigun Helios EgoBot Gregor-Reddak-Ehird-Anmaster-Tritonio, which would be very weird.
23:00:50 * EhirD` has a reflex that coils on sight of "Elliot" and corrects people to "Elliott"
23:00:55 <oerjan> RodgerTheGreat: of course not, your real name is Spot
23:01:00 <IhopE> But it's "Elliot"!
23:01:14 <IhopE> Well, too bad! :-P
23:01:46 <RodgerTheGreat> http://rodger.nonlogic.org/dump/images/1190852142-understanding.png
23:02:04 <EhirD`> yes but that's because its littered in various code and i might have told you
23:02:35 <oerjan> EhirD`: maybe i got it from your code too
23:02:48 <EhirD`> i haven't shown all that much code here
23:02:50 <oerjan> that was my second theory anyway
23:05:08 <oklopol> EhirD`: perhaps, although i'm pretty sure i've just deduced it from your behavior, just like i did with GregorR
23:05:24 <EhirD`> you deduced Elliott Hird from my behaviour?
23:05:31 <EhirD`> well, of course you could deduce E Hird
23:05:34 <EhirD`> But Elliott? i doubt it
23:05:53 <oklopol> EhirD`: no no i'm pretty sure
23:06:10 <EhirD`> oklopol: james randi might want to giv e you $1mil
23:06:22 <RodgerTheGreat> fine, have some doodles from my statistics class today: http://nonlogic.org/dump/images/1193866302-sket2.png
23:06:25 <EhirD`> i'm pretty sure being able to determine names from behaviour is psychic
23:07:16 <oklopol> hehe, a guy in my class does that too
23:07:22 <EhirD`> IhopE: how's the spec going?
23:07:37 <oklopol> if there's a pause in taking notes, he draws a random picture
23:08:47 <oklopol> you use both hands and take notes while drawing?
23:08:52 <IhopE> EhirD`: I'll post it in exactly one moment.
23:09:02 <IhopE> What I have, I mean. Not the whole thing.
23:09:13 <oklopol> i'm pretty sure i saw a graph in there! :)
23:09:31 <RodgerTheGreat> because I find statistics extremely uninteresting, considering how many times I've done it in various classes over the years
23:10:12 <oklopol> statistics does have an ugly sound to it.
23:10:25 <oklopol> anyway, i'll sleep for a moment now, you all have fun ->
23:10:56 <AnMaster> <IhopE> Or Rodger Tokigun Helios EgoBot Gregor-Reddak-Ehird-Anmaster-Tritonio, which would be very weird. <-- huh?
23:11:08 <IhopE> AnMaster: don't you think that would be a very weird name?
23:11:45 <AnMaster> IhopE, none of these are real names
23:12:12 <IhopE> GregorR mentioned pretending everyone's nick was derived the same way as his.
23:12:34 <bartw> why is stdcall right to left with arguments ?
23:12:44 <oerjan> Gregor isn't a real name? :)
23:12:44 <EhirD`> bartw: because stdcall is evil
23:13:12 <AnMaster> <IhopE> GregorR mentioned pretending everyone's nick was derived the same way as his. <-- and how is it?
23:13:22 <AnMaster> mine IS based on my initials (AN) yes
23:13:28 <IhopE> First name, last initial.
23:13:52 <oerjan> my name is obviously Oerja Nilsson. Sorry for fooling you all about my gender so long.
23:13:54 <oklopol> my real name is oklovonimol polokolmonopotol
23:14:18 <AnMaster> oerjan, hm, sounds Scandinavian
23:14:50 <EhirD`> oerjan: YOU FAKED YOUR PHOTO?!12567862874623784234
23:14:51 <GregorR> oerjan: Gotta tell you, "Oerja" doesn't strike me as male or female :P
23:14:54 <AnMaster> oerjan, still don't know gender of name
23:15:03 <oerjan> EhirD`: no i'm just very ugly.
23:15:12 <bartw> RodgerTheGreat: nice drawings
23:15:26 <AnMaster> oerjan, wait, "oe" O with / in?
23:15:35 <AnMaster> oerjan, same as Swedish örjan then?
23:15:43 <oerjan> GregorR: well if it was norwegian it would be female. The only exception i recall is "Ola"
23:16:04 <oerjan> (ending in -a that is)
23:16:53 -!- IhopE has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
23:17:27 <AnMaster> my name can be found in the source code of the brainfuck interpreter in bash I coded: http://rage.kuonet.org/~anmaster/bzr/index.py/get/bashfuck/head/bashfuck
23:17:49 <AnMaster> I'm also working on a modular irc bot in bash (http://envbot.org)
23:18:15 <GregorR> I imagine you have a library of functions that turns bash into a bit more of a general-purpose language?
23:18:16 <AnMaster> GregorR, still, just compiling LostKing.b to byte code = about 10 minutes on my amd64
23:18:20 * GregorR has always enjoyed writing shell scripts :)
23:18:27 <EhirD`> his lostkng.b performance is terrible
23:18:48 <AnMaster> if someone can make it faster, please branch it
23:19:45 <oerjan> "We're all mad here. I am mad. You're mad." "How do you know that I am mad?" asked Alice. "You must be," said the Cat, "or you wouldn't have come here."
23:20:04 <AnMaster> GregorR, I do have some stuff I reuse sometimes, stack functions, associative array emulation
23:20:13 <EhirD`> ah yes -- quoting alice in wonderland. The post-ironic hippy way to be cool on the internet.
23:20:14 <AnMaster> but for bashfuck I didn't reuse anything
23:20:57 <AnMaster> I guess quoting Terry Pratchett doesn't work?
23:21:09 <EhirD`> no, that's the post-hippy ironic way
23:21:35 <AnMaster> EhirD`, eh? I got all Terry Pratchett books (except a few short stories that are out of print)
23:21:54 <AnMaster> EhirD`, and what is the post-hippy post-ironic way?
23:21:59 <oerjan> actually i am quoting Narbonic, which quoted Alice in Wonderland.
23:22:44 <oerjan> my favorite mad science webcomic so far
23:23:04 <AnMaster> (hm what is a "mad science webcomic"?)
23:23:05 <EhirD`> AnMaster: google gives it as #1 result
23:23:22 <oerjan> http://www.narbonic.com/
23:24:13 <AnMaster> EhirD`, what? I used to read that nethack one too, dudly or whatever the name was
23:24:53 <AnMaster> oerjan, there is no strip on the page?
23:25:00 <AnMaster> or do I have to enable java script
23:25:31 <EhirD`> sheesh, you could just view source
23:25:35 <EhirD`> and also stop being JS-paranoid
23:25:36 <oerjan> AnMaster: the webcomic is finished, read the archive
23:25:40 <AnMaster> <script language=javascript src=http://www.webcomicsnation.com/tooncast.php?series=narbonic_plus></script> <br>
23:25:53 <AnMaster> noscript tells me there is java script
23:26:16 <EhirD`> disable noscript becaues it's a stupid, paranoid extension with no real practical value
23:26:30 <AnMaster> GregorR, btw envbot's performance is very good
23:26:41 <AnMaster> EhirD`, what? I use tor when I browse
23:26:46 <oerjan> oh right, director's cut rerun. i haven't read that.
23:27:02 <EhirD`> i guess you wear a tinfoil hat too
23:27:46 <oerjan> heh, today's rerun is pretty good
23:27:56 <AnMaster> <EhirD`> i guess you wear a tinfoil hat too <-- no?
23:34:24 <EhirD`> Not Invented Here strikes again!
23:34:29 <EhirD`> I have found myself writing a code editor.
23:34:54 <oerjan> AnMaster: does http://www.webcomicsnation.com/shaenongarrity/narbonic/series.php?view=archive&chapter=9763 work better? it's the first page of the archive.
23:38:10 <AnMaster> bsmntbombdood, yes I coded brainfuck interpreter in bash. Yes I'm mad. Do you want anything else? :P
23:38:29 <bsmntbombdood> writing a brainfuck interpreter in bash doesn't make you mad around here
23:38:36 <AnMaster> http://rage.kuonet.org/~anmaster/bzr/index.py/get/bashfuck/head/bashfuck and http://envbot.org is proof enought I'm mad
23:38:57 <AnMaster> bsmntbombdood, using bytecode and optimiztions in the interpreter AND coding it in bash IS mad
23:39:04 <bsmntbombdood> writing bash in brainfuck, that would make you mad
23:39:18 <EhirD`> mad for doing the impossible
23:40:36 <AnMaster> bsmntbombdood, what about bash to C translator coded in bash?
23:49:54 <RodgerTheGreat> mad science webcomics, eh? How about Phil Foglio's Girl Genius? (http://nonlogic.org/dump/images/1193870414-idee.png)
23:50:32 <oerjan> RodgerTheGreat: reading that too :)
23:51:32 <oerjan> among other defunct/ended ones: Casey and Andy, A Miracle of Science
23:53:13 <RodgerTheGreat> lmao. "..It heartens me to look ahead and see the bright future each and every one of you will create, using your disciplines to improve our world. Except for the computer-science majors. They're more likely to perpetrate evil."