00:00:35 <ehird`> i'm providing a non-monadic [BF] parseBF, is that good parsec style? :P
00:04:40 <ehird`> case (parse program name code) of Left e -> error (show e)
00:06:59 <ehird`> by the way, oerjan, is this a good way to cut down on overflow checks in compiled bf code:
00:07:11 <ehird`> well, without >< reduction, ofc:
00:07:18 <oerjan> actually i would probably make it use a print statement and let the Right p -> part call the actual interpreter
00:07:28 <ehird`> "p++;p++;p++;p--;CHECKMEM;t[p]++;"
00:08:00 <ehird`> "well, without >< reduction, ofc:"
00:08:03 * oerjan has never written a real compiler
00:10:09 <oerjan> i recall that strictly speaking any of the p++ might fail if more than 1 beyond the allocated array... may not be a real problem
00:10:46 <oerjan> i.e. actual pointer arithmetic is undefined behavior in that case, possibly
00:10:53 <Slereah> Making some sort of Dungeons and Datas programs is hard.
00:11:06 <Slereah> It has to make sense to be of any interest!
00:11:37 <Slereah> Well, some sort of sense at least.
00:12:43 <ehird`> compiler goals: 1. be fast 2. don't use things that are machine-specific by design
00:23:06 -!- ehird` has left (?).
00:23:11 -!- ehird` has joined.
00:23:13 <ehird`> wedge :: String -> String -> String -> String
00:23:17 <ehird`> wedge :: String -> String -> String -> String
00:27:12 <ehird`> wedge :: (Show a) => a -> String -> String -> String
00:30:02 <ehird`> oerjan: i CANNOT figure out the type errors i get with this: http://hpaste.org/4820
00:31:26 <oerjan> what _are_ the type errors?
00:31:39 <ehird`> Couldn't match expected type `Char' against inferred type `String'
00:31:39 <ehird`> Expected type: BF -> [Char]
00:31:39 <ehird`> Inferred type: BF -> [String]
00:31:39 <ehird`> In the first argument of `map', namely `(indent . compile')'
00:31:39 <ehird`> In the first argument of `(++)', namely
00:31:39 <ehird`> `map (indent . compile') prog'
00:31:50 <ehird`> Couldn't match expected type `Char' against inferred type `String'
00:31:51 <ehird`> Expected type: BF -> String
00:31:51 <ehird`> Inferred type: BF -> [String]
00:31:53 <ehird`> In the first argument of `map', namely `(indent . compile')'
00:31:54 <ehird`> In the first argument of `(++)', namely `map (indent . compile') b'
00:32:32 <oerjan> you want concatMap instead of map i think
00:36:39 <ehird`> oerjan: flatten [[1,2],[3,4]] -> [1,2,3,4]
00:37:21 <oerjan> concatMap f l = concat (map f l)
00:38:49 <ehird`> gcc optimizes a+0 i hope
00:39:52 <ehird`> oerjan: what's that haskell function that acts as a filter?
00:40:00 <ehird`> that is, stdin->func->stdout
00:43:24 <ehird`> gcc also optimizes x -= -x i hope :P
00:44:09 <oerjan> exactly _where_ was your compiler going to do its optimizations you said? ;)
00:44:40 <ehird`> in the Optimize module
00:44:49 <ehird`> which ain't written yet
00:45:45 <ehird`> oerjan: iterative optimization, too!
00:45:49 <ehird`> imperative pseudo-code:
00:46:29 <ehird`> while optimize(prog) != prog { prog = optimize(prog) }
00:46:38 <ehird`> there's probably a nice haskelly way to express that :P
00:49:05 <oerjan> iterate optimize somehow
00:49:31 <ehird`> thank you you are helpful
00:49:52 <oerjan> er, iterate is a function :)
00:50:16 <oerjan> that equality comparison may be expensive though
00:50:51 <ehird`> yeah, it would be like
00:50:58 <ehird`> let opt = optimize(prog) in ...
00:51:21 <ehird`> anyway, iterate useful for...?
00:51:33 <oerjan> well maybe this easier with explicit recursion
00:51:38 <ehird`> it seems to produce a list
00:52:19 <oerjan> you usually search the resulting list until you find the point you want
00:53:21 <ehird`> hm confusing definition
00:53:33 <oerjan> however it may need some cleverness to avoid calculating things twice
00:55:54 <oerjan> in principle until (\x -> x == optimize x) optimize would do _but_ it might calculate optimize twice
00:56:19 <ehird`> i can't see a way out of that
00:57:53 <oerjan> untilEq f x | x == y = x
00:58:15 <oerjan> | otherwise = untilEq f y
00:59:30 <ehird`> optimizeFully p = case optimize p of p -> p x -> optimizeFully x
00:59:31 <oerjan> doesn't appear to exist
01:00:00 <oerjan> unfortunately the of p binds a new variable
01:00:43 <Sgeo> Maybe I'll start working on PSOX again on Monday..
01:01:22 <oerjan> you _could_ do something with pairs but it wouldn't be any clearer than explicit recursion
01:03:39 <oerjan> fst . head . dropWhile (uncurry (/=)) . tail . iterate (fst &&& optimize . snd) . (,) undefined
01:03:55 <ehird`> drunk on lambdabot, oerjan?
01:04:18 <oerjan> lambdabot? i did that in my head
01:04:59 <oerjan> i expect @pl would produce something far worse
01:05:36 <oerjan> @pl'ing is a rather esoteric thing to do :)
01:06:37 <ehird`> optimizeFully p = let opt = optimize p in if opt == p then p else optimizeFully opt
01:06:42 <oerjan> of course it's just a slightly more civilized abstraction elimination
01:06:53 <ehird`> No instance for (Eq Jill.Core.BF)
01:07:55 <oerjan> but as i said, i think that could be expensive, especially if optimizations happen only deeply
01:09:41 <oerjan> comparing this step to the next, recursively?
01:10:05 <ehird`> oerjan: damn, optimizing BFSet will be hard with patmatching
01:10:13 <ehird`> Set/Inc/Read/Write ... BFSet
01:12:39 <ehird`> for what values of n in BFLoop x [BFInc y n] can it be proved to be BFSet (x+y) n?
01:13:37 <oerjan> if you assume a binary representation with wrapping on a fixed bitwidth
01:13:42 <oerjan> then any odd n will do
01:15:21 <ehird`> optimize (BFInc x a):(BFInc x b):xs = (BFInc p (a+b)):xs
01:15:22 <ehird`> parse error in pattern!
01:16:23 <oerjan> optimize ((BFInc x a):(BFInc x b):xs) = (BFInc p (a+b)):xs
01:16:54 <oerjan> optimize (BFInc x a : BFInc x b : xs) = BFInc p (a+b) : xs
01:17:14 <ehird`> Conflicting definitions for `x'
01:17:15 <ehird`> In the definition of `optimize'
01:17:30 <ehird`> can't i use the same name for 'equal'? :(
01:17:58 <oerjan> optimize (BFInc x a : BFInc x' b : xs) | x == x' = BFInc p (a+b) : xs
01:19:38 <ehird`> optimize (BFLoop x [BFInc x' n] : xs) | mod n 2 == 1 && x == x' = BFSet x 0 : xs
01:20:12 <faxathisia> that gives me the feeling this code would be easier in lisp
01:20:22 <oerjan> it may help to include a line break
01:20:49 <faxathisia> so you can express the optimizations however you like (and hide a big confusing macro somewhere no noe looks)
01:20:56 <oerjan> line break + at least one space
01:24:46 <ehird`> p += 1; t[p+0] = 0; p += 1; t[p+0] = 0;
01:24:49 <ehird`> repeated loads of times
01:24:53 <ehird`> i have a feeling that's optimizable :P
01:25:13 <ehird`> that is, code X repeated N times = for (tmpvar=0;tmpvar<N;tmpvar++){X}
01:25:27 <ehird`> bit tricky for a pattern match though
01:26:50 <oerjan> finding repeating subsections of a list, hm
01:29:59 <oerjan> hm if you consider sort . tails you get equal sublists nearby each other
01:30:18 <oerjan> it could be the basis of an algorithm.
01:30:27 <oerjan> probably a bit expensive though
01:31:22 <oerjan> you could somewhat identify subfunctions that way
01:31:57 <ehird`> heh, now that IS interesting, but implausible
01:32:06 <ehird`> but finding repeating subsections would be useful.
01:32:14 <ehird`> i also want to identify 'if's
01:34:48 <ehird`> sheesh, gcc should have a -Ocs
01:34:52 <ehird`> optimize for compilation speed
01:34:56 <ehird`> this thing takes ab out 20 seconds to compile
01:35:23 <ehird`> oh, wonderful, it seems mandelbrot.b tape underflows forn o reason
01:37:14 <ehird`> p += -1; if ((p+(-1))==0) { ... }
01:37:17 <ehird`> that should execute, right?
01:43:02 <ehird`> wtf, 9 seconds for mandelbrot
01:45:12 <Sgeo> Why have I not been working on PSOX??
01:46:43 <Slereah> You've been thinking "I'll just do it later" for several days?
01:46:51 <ehird`> Slereah: No, I got 3 seconds before
01:47:22 <Slereah> Compared to the... roughly 3 hours per line I got on the Love Machine 9000.
01:47:36 <ehird`> 9 seconds is the speed that BF interps get for mandelbrot.b
01:48:13 <ehird`> hm, did i lose my network connection?
01:56:00 * ehird` just uses the OS' memory protection, for simplicity
01:56:03 -!- jix has quit ("CommandQ").
01:56:14 <ehird`> And a sigsegv handler to expand
01:56:41 <ehird`> Now, who wants to tell me how to calculoate the page size in C...
01:57:09 <Slereah> I want to, I just don't know how to do it!
01:57:34 <ehird`> oerjan: Confusing isn't it!
01:58:42 <ehird`> the low-elvel useful things that c can't do
01:59:48 <oklopol> for some reason i wanna know how fast egobf is, please, ehird`, find it out for me :D
01:59:58 <ehird`> not as fast as bf2c.hs
02:00:01 <oklopol> i have no idea why, one of my random obsessions
02:01:06 <ehird`> iirc. about 3 seconds.
02:01:15 <ehird`> but it bus errors on this mac.
02:01:20 <ehird`> so: that's just a guess
02:03:32 <ehird`> but yeah: page size determination.
02:06:43 <oklopol> but most of what i know i've learned from you.
02:07:28 * oklopol is very proud for actually having learned to use linux in just *six months*
02:10:23 <ehird`> % time ./mandelbrot > /dev/null
02:10:23 <ehird`> ./mandelbrot > /dev/null 3.41s user 0.02s system 98% cpu 3.477 total
02:26:58 -!- Jontte has quit ("Konversation terminated!").
02:27:17 <Slereah> It's hard to check an abstraction eliminator when you can't even do it by hand correctly!
02:27:58 <faxathisia> Slereah: One check is shoving them through a type checkera
02:29:15 <oklopol> (is he correcting a grammar error or making a very complicated comma pun, we'll never know...)
02:29:43 <Slereah> maybe it was a ? without the shift!
02:30:10 <Slereah> I'm trying to correct one error of my Abstractor,.
02:30:33 -!- ehird` has quit.
02:30:58 <Slereah> Apparently, it doesn't like very much something of the form ^abc...(^xyz...)fgh...
02:31:21 <Slereah> Although even the successor function doesn't seem to work too well.
02:32:52 <oerjan> well deeply nested lambdas do blow up exponentially with the naive AE algorithm
02:35:08 <Slereah> Blow up as in "size increase" or "Make them wrong"?
02:35:56 <Slereah> That doesn't worry me too much, that's why I made a program.
02:36:14 <Slereah> it's the wrong expression I find worrying
02:36:32 <Slereah> Although I can't be too sure if it's the abstractor or the interpreter.
02:39:52 -!- calamari has quit ("Leaving").
02:40:25 <oerjan> i would offer my eliminator but it's heavily tailored to unlambda (uses d and is careful about strictness)
02:42:02 -!- Sgeo has quit (Connection timed out).
02:42:31 <Slereah> Can you try this pred. function on unlambda, if you can copypasta on it? http://membres.lycos.fr/bewulf/Russell/Pred.txt
02:42:41 <Slereah> Just to see which program is the problem.
02:43:01 -!- Sgeo has joined.
02:44:32 <oerjan> well it's accepted and does nothing
02:45:01 <oerjan> and it is well-formed, because changing the final i to ! causes an error
02:46:47 <Slereah> Well, I try it with ``pred n `.xi
02:47:00 <Slereah> In a lazy evaluation, that is.
02:47:04 <oerjan> my optimizer simplifies it to ``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s`k`s`kkk`k``s`k`s`k`s`k`si``s`k`s`k`s``s`ksk``s`k`s`k`s`kk``s`k`s`kkk`k`kk`k`k`ki
02:47:28 <Slereah> It always only prints 1 x for all values of n on mine
02:50:52 <oerjan> um shouldn't that be ```pred n .x i ?
02:51:50 <oerjan> then it works nicely here
02:52:40 <oerjan> with ``pred n `.xi you are applying `pred n to too few arguments
02:53:05 <oerjan> so it just passes on to evaluating `.xi itself i assume, and just once
02:53:07 <Slereah> `n`.xi seems to work though
02:54:04 <oerjan> here is the 256 from my self-interpreter: ```s``s`kski
02:55:21 <oerjan> with that, ```pred n .x i prints 255 x'es in the unlambda C (i think) interpreter
02:57:20 <Slereah> (^f^x.f(f(f(...f(x)...)))) (.xi) = ^x.(.xi)((.xi)((.xi)(...(.xi)(x)...))) no?
02:57:30 <Slereah> It should at least evaluate more than 1?
02:57:55 <Slereah> Although I'm not too sure what it would be in combinators.
02:58:25 <oerjan> er it takes 2 arguments
02:59:51 <Slereah> Here's a run for `2`.xi : http://membres.lycos.fr/bewulf/Russell/2%20run.txt
03:00:45 <oerjan> you may be right. however:
03:01:20 <oerjan> ``pred n f may not expand to the same as `(n-1) f
03:01:45 <oerjan> rather, it may expand to something which waits for another argument before even starting to copy f's
03:02:14 <Slereah> So f is evaluated first, and only one x is printed?
03:03:12 <oerjan> the thing is, while expanding top-level, f is never evaluated
03:03:50 <oerjan> it is only when your interpreter gives up the top-level because there isn't anything more to evaluate there, that it gets down to the f
03:04:49 <Slereah> ```pred n .x i seems to work
03:05:46 <Slereah> Let's see how succ n fares.
03:07:16 <Slereah> Output isn't easy to deal with under any evaluation!
03:09:28 <Slereah> When I'm more enthusiastic, I should try to see the evaluation of ``pred n`.xi
03:09:31 <oerjan> i think I/O behaves more reasonably if you only evaluate those operations at top level. then it works almost like monads...
03:11:28 <Slereah> What is exactly meant by top level?
03:12:49 <oerjan> the top of the parse tree
03:13:06 <oerjan> or in your case, only the start of the string for finding operators
03:15:27 <Slereah> Or maybe not, the connection seems to be back
03:18:57 <Slereah> I'd check the run of the predn`.xi, but it looks like this : http://membres.lycos.fr/bewulf/Russell/Pred%20run.txt
03:19:30 <Slereah> Although I could try in your optimized version.
03:20:27 <Slereah> It's more reasonably sized.
03:20:51 <oerjan> i haven't checked it, it just came out of ulify2.scm :)
03:21:57 <Slereah> Well, at least the predn.xi seems to print the right number of x's.
03:22:16 <oerjan> ah yes, yours contains things like ``s`kk`ks
03:22:35 <Slereah> Is that a conversion of some sort?
03:23:10 <Slereah> I should add it with the eta conversion.
03:23:40 <oerjan> except in unlambda you need to add d's to it
03:23:52 <oerjan> but somehow i didn't see any in the result you saw
03:24:21 <oerjan> (my optimizer also tries to remove d's again)
03:24:36 <Slereah> Well, it's made of only primitive combinators. I assume that the evaluation isn't very important without IO
03:24:58 <oerjan> it depends. it can still be non-terminating.
03:25:58 <oerjan> if `fg doesn't terminate, then ``s`kf`kg cannot be simplified to `k`fg
03:26:57 <Slereah> Wouldn't ``s`kf`kg be ``Sfg?
03:28:15 <Slereah> ```s`kf`kgz = ```kfz``kgz = ``fz`gz = `sfg?
03:30:44 <oklopol> "<Slereah> maybe it was a ? without the shift!" <<< sorry, that'd be +
03:31:02 <Slereah> On what moonspeak keyboard are you typing?
03:31:21 <oerjan> if oklopol's keyboard is like mine it could be ; without the shift, though
03:31:30 <oerjan> mine also has + below ?
03:31:30 <Slereah> (Does this conversion have a name? It's just to look pretty in the code)
03:32:45 <oerjan> well when you do it directly on lambdas it's just ^x`fg = `k`fg instead of ``s`kf`kg
03:33:09 <oerjan> so it's a shortcut, which madore mentions on the unlambda page
03:33:17 <oerjan> (noting that it is unsafe in unlambda)
03:33:20 <Slereah> So just an artefact of the conversion.
03:35:44 <oklopol> hmm, if it was ";", it was obviously a request to change the subject
03:36:05 <oklopol> or "you make too long sentences, wrap it up"
03:36:12 <oklopol> okay, not that obvious :-)
03:36:45 <oklopol> did someone here link maddox' rants?
03:39:09 <oklopol> http://maddox.xmission.com/
03:39:51 <oklopol> i've written similar articles, although more, and of worse quality (or at least not better)
03:40:03 <oklopol> probably the reason i found them interesting
03:40:29 <Slereah> ```s`k`ab`k`cdk -> ```ab`cdk
03:41:28 <Slereah> A much shorter result for pred!
03:41:37 <oerjan> um you're missing a `k
03:42:46 <oklopol> Slereah: did you paste the original link? asdf guess i need to press ctrl+f :'(
03:44:26 <Slereah> oerjan : I guess that explain the infinite loop I got for pred
03:46:53 <Slereah> Any other ways to reduce ski to ski?
03:48:26 <Slereah> Although the pred down to ``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s`k`s`kkk`k``s`k`s`k`s`k`si``s`k`s`k`s``s`ksk``s`k`s`k`s`kk``s`k`s`kkk`k`kk`k`k`ki is already pretty neat.
03:48:53 <Slereah> Seems to be the same as yours
03:51:58 <oerjan> yep, you now have the two main optimizations of mine
03:52:10 <oerjan> and the rest i think are unlambda-specific
03:53:41 <Sgeo> Can a forkbomb cause lasting damage to a system?
03:53:52 <Sgeo> I'm contemplating using a forkbomb to force myself off the computer
03:54:10 <Slereah> You could ask your mom to do that.
03:55:25 <Slereah> Do you have a particular way of finding those optimisation?
03:55:45 <Slereah> I'm thinking of trying it for some other combinators.
03:58:33 <Slereah> (And maybe combining the ski-unlambda translator, the abstractor and the interpreter to write programs in some unholy combination of SKI combinators, unlambda and lambda calculus!)
04:05:28 -!- Sgeo_ has joined.
04:14:03 -!- _KS has quit.
04:15:18 -!- Sgeo has quit (Read error: 110 (Connection timed out)).
04:27:03 <Slereah> There's the unholy Frankenstein : http://membres.lycos.fr/bewulf/Russell/Lazylambda4.py
04:36:38 <Slereah> When I'm done with this, every damn letter will be a combinator! :o
04:44:38 <oklopol> lol i made a bit of a miscalculation when saying i have more articles than this guy, i now realize i haven't read more than 30%, thought i was finished :)
04:44:53 <oklopol> the scroll bar... it's just too complex.
04:45:38 <Slereah> There's 10 years of article!
04:46:27 <Slereah> Writing in that mix of calculi is more pleasant.
04:46:44 <Slereah> For instance, some sort of iszero checker : ```^n((n(^x`ki))k)(^a^b`a`ab)`.0i````.F.a.u.xi
04:46:56 <Slereah> Where (^a^b`a`ab) can be any number.
04:47:36 <Slereah> With some hodgepodge of ` and parenthesis just for pleasure!
04:50:06 <Slereah> It thinks I want to use i as a lambda variable.
04:51:39 <Slereah> Either I remove the ^s ^k ^i checker or find some way around it.
04:53:42 <Slereah> .^ in general seems to be a nuisance.
04:53:46 <oerjan> it's too simplistic, not skipping .'s
04:54:20 <oerjan> i mean, checking for the literal string ^s etc. anywhere
04:55:05 <Slereah> But if there's `.^i, it will find the string ^i in it.
04:55:27 <Slereah> And think I'm trying to sneak in some ski as variables.
04:56:06 <Slereah> And since `fg has ^ in it, the Abstractor will try to abstract it, instead of leaving it alone.
04:56:15 <oerjan> perhaps you could put the check in something like wff instead?
04:56:24 <Slereah> I should make some function to differentiate .^ from ^
04:57:01 <oerjan> don't forget you can have ..^ etc.
04:57:22 <Slereah> That's why I'm thinking of a function instead of a lazy ass workaround.
04:57:43 <Slereah> (I had plenty of similar problems on the Love Machine 9000!)
04:59:46 <Slereah> I should check for an odd number of . before ^ I guess.
05:15:14 <oerjan> question: do you allow ^. ?
05:18:00 -!- Sgeo_ has quit (Remote closed the connection).
05:18:06 <Slereah> Although a (^x`.yi) expression seems to pose problem.
05:18:23 <Slereah> When it tries to abstract ^x.y
05:19:45 <oerjan> well my question was because it could break your odd number of . 's rule
05:19:58 <Slereah> It thinks that ^x.y is actually two combinators.
05:20:31 <Slereah> Printing functions are quite annoying to implement.
05:25:29 <Slereah> Just a number error in the T[^x.y] -> `ky
05:27:42 <Slereah> It doesn't crash, but it's not that good either.
05:27:48 <oerjan> oh and not to forget ^^ :D
05:28:11 <Slereah> ^..^ gives i, ^...^s gives ``si`ks
05:28:30 <Slereah> ^^ makes some infinite loop.
05:28:50 <Slereah> Although ^^^ translates as i okay.
05:28:55 <oerjan> my suggestion is to disallow ^ and . as variables
05:33:24 <Slereah> Well, right now, the program will change all non-printing ( into ` (or delete them if they're before ^), delete all non-printing ), change all variables and combinators into lowercase, eliminate abstraction from the result and read the result as Unlambda would.
05:33:46 <Slereah> Any parsing pitfall in mind?
05:35:30 <oerjan> ( -> variable number of ` 's right?
05:36:30 <oerjan> um ( before ^ shouldn't be deleted should it
05:37:13 <Slereah> Well, the ^abc... abc... in parenthesis is just for a clear way to see the whole lambda expression if I want to write it.
05:38:21 <Slereah> It poses problems if I want to write something like `(^a^b`ba)np
05:38:31 <oerjan> however you could then have an error if the lambda expression stops before the corresponding )
05:39:13 <oerjan> what about instead saying ( before ^ moves past the ^+variable?
05:39:55 <oerjan> then you could drop ` 's inside
05:39:55 -!- slereah_ has joined.
05:40:08 <slereah_> [06:39] <Slereah> Although I guess I could check the length of the lambda expression to delete or not the parenthesis
05:40:56 <oerjan> oerjan> however you could then have an error if the lambda expression stops before the corresponding )
05:41:26 <oerjan> oerjan> what about instead saying ( before ^ moves past the ^+variable?
05:41:38 <oerjan> oerjan> then you could drop ` 's inside
05:41:45 <slereah_> That's what the "what?" was for.
05:42:52 <oerjan> `(^a^b`ban)p -> `^a^b(`ban)p -> `^a^b``banp
05:44:16 <slereah_> Well, except it should be ``^a^b`bap
05:45:01 * slereah_ uses the power of mental thinking
05:45:37 <slereah_> `(^a^b`ban)p wouldn't be legal.
05:45:57 <slereah_> That's ^a^b`ban applied to p, but `ban lacks one apply.
05:47:00 <oerjan> it's legal in lambda calculus to be applied too little
05:47:25 <oerjan> the point i was saying was
05:47:56 <oerjan> and in ordinary lambda calculus a ^ usually continues until the next )
05:48:26 <oerjan> so why not say that (^a^bban) = ^a^b``ban
05:48:45 <slereah_> Well, I could do that for all variables.
05:49:15 <slereah_> Replace n non-printing letters by ````...````abcd...xyz
05:49:54 <oerjan> although it may be weird if you mix things, hm
05:50:14 <oerjan> since ^a without parentheses only takes one following expression
05:50:37 <slereah_> I don't know about weirdness, but it might be hard to check for accuracy.
05:50:49 <slereah_> That would be a whole lot of combinations to try.
05:51:48 <oerjan> you could say ` introduces unlambda syntax and ( introduces lambda calculus syntax
05:52:08 <slereah_> The thing is, I'm mixing both.
05:52:24 <slereah_> For instance if I'm lazy and just want to copypasta some expression.
05:52:43 <oerjan> so if a subexpression starts with ` or ( you change to the other
05:53:28 <slereah_> Actually, both notations are used for both.
05:53:33 <oerjan> it would be safe as long as what you paste either is parenthesized or is a single expression starting with `
05:53:50 <oerjan> well they have ^ in common
05:59:31 <slereah_> Well, it can now differentiate s=s[:i]+s[i+1:]
05:59:46 <slereah_> `(^a^b`ban)p and ``(^a^b`ba)np
06:00:06 <slereah_> But I don't know what will happen if there's more lambda inside the parenthesis.
06:00:25 -!- Slereah has quit (Read error: 110 (Connection timed out)).
06:00:30 -!- slereah_ has changed nick to Slereah.
06:00:58 <oerjan> ah yes there could be trouble
06:01:33 <oerjan> the ^b would probably scope only the b
06:01:38 <Slereah> I was thinking more of ((^aa)(^bb)a)
06:02:19 <oerjan> that should be fine if the outer ( is handled first
06:03:49 <oerjan> -> ^a(a(^bb)a) -> ^a``a(^bb)a -> ^a``a^bba
06:03:50 <Slereah> Reads it as `^aa^bba. But it should be... What should it be, actually?
06:04:30 <Slereah> Doesn't read it like that.
06:06:50 <Slereah> But well, I guess it's not too important.
06:15:50 <Slereah> Hm. Would a combinator-to-text be something like iszero n [print char 0] [iszero pred(n) [print char1] [...]]]?
06:17:11 <Slereah> So something actually like (^x . iszero x [print char 0] [iszero pred(x) [print char1] [...]]]) n
06:18:22 <oerjan> there is a church numeral printer hidden in my deadfish-in-unlambda code
06:18:36 <oerjan> it might be using d though
06:19:09 <Slereah> I guess I could just generate it in python for ASCII chars.
06:19:33 <oerjan> oh you want num->ascii
06:19:52 <Slereah> Well, num->any set of char, actually.
06:20:12 <Slereah> ASCII works okay, especially since I want to do a _ combinator.
06:20:41 <Slereah> Awaits input from the keyboard, and then converts it to some ASCII Church numeral.
06:20:48 <oerjan> but i wouldn't use pred. i would use a church-encoded list of the chars
06:21:13 <oerjan> and then do `head ``n tail list
06:21:34 <Slereah> Ah yes. I should read the list function for lambda calc.
06:22:21 <faxathisia> (define (cons x y) (lambda (k) (k x y))) (define (car cons) (cons (lambda (x y) x))) (define (cdr cons) (cons (lambda (x y) y)))
06:22:40 <Slereah> I can't really read Haskell.
06:23:14 <oerjan> given that that was scheme, i believe you :D
06:23:40 <Slereah> Scheme, Haskel, same thing!
06:23:52 <Slereah> ^ is just a fancy ASCII for lambda.
06:24:40 <faxathisia> well to make a cons (pair of things), you can make a closure which takes a function an applies it to those args
06:25:03 <oerjan> in fact haskell is closer
06:25:15 <oerjan> cons = \h t -> \k -> k h t
06:25:30 <faxathisia> so to select the head, such that (head (cons a b)) = a, head = (^cons. (cons (^head tail . head)))
06:25:57 <oerjan> though sadly, church-encoded lists soon hit against the type system
06:27:17 <Slereah> Why is a pairing noted as "cons"?
06:28:34 <oerjan> http://en.wikipedia.org/wiki/Cons
06:28:46 <Slereah> But, pair has the same number of letters! :o
06:29:11 <Slereah> Is there a Lisp function called pair?
06:30:27 <Slereah> ````^m^n^f^x``nf``mfx^f^x`f`f`f`f`f`fx^f^x`f`f`f`fx.xi
06:31:05 * faxathisia should probably shut up and stop confusing people
06:31:41 <Slereah> If we weren't allowed to confuse, it would be pretty silent.
06:32:11 <oerjan> and then, what would the alligators do?
06:32:26 <Slereah> You are confusing me oerjan.
06:32:34 <Slereah> My lazy unlambda has one clear advantage on the love machine 9000.
06:32:44 <Slereah> I have a perfect name for it.
06:32:55 <Slereah> It will be called "Lazy bird".
06:33:14 <Slereah> Since its combinators will be the combinator birds from "To mock a mockingbird".
06:33:50 <Slereah> And it's a name I can post on Esolang without shame, unlike "Love Machine 9000".
06:34:31 <Slereah> Although I came up with a srs business name for it.
06:35:39 <oerjan> Srpska Radikalna Stranka?
06:36:21 <Slereah> http://www.encyclopediadramatica.com/The_Internet_is_serious_business
06:38:21 * oerjan has a lightbulb go off
06:40:30 <oerjan> you mean srs is _not_ an acronym? doesn't sound like serious business to me.
06:42:52 <Slereah> There's a dick that shouldn't be in your sentence.
06:43:49 <oerjan> my sentience is none of your business.
06:52:22 <Slereah> Fixed point combinators are not especially rare (there are infinitely many of them). Some, such as this one (constructed by Jan Willem Klop) are useful chiefly for amusement:
06:52:22 <Slereah> Yk = (L L L L L L L L L L L L L L L L L L L L L L L L L L)
06:52:22 <Slereah> L = ?abcdefghijklmnopqstuvwxyzr. (r (t h i s i s a f i x e d p o i n t c o m b i n a t o r))
06:52:52 <Slereah> Let's see if I can make something similar!
07:01:50 <Slereah> Well, it might take a while.
07:02:34 <Slereah> It's doing the w's right now, and increasing in size!
07:02:50 <Slereah> I hope it eta-reduces a whole lot.
07:11:45 <oerjan> well 10 of the variables are not used
07:13:23 <Slereah> ^a^b^c^d^e^f^g^h^|^j^<^l^m^n^o^p^q^$^t^u^v^w^x^y^z^r`r``````````````````````````th|$|$af|xedpo|ntcomb|nator is still running :o
07:18:05 <Slereah> http://membres.lycos.fr/bewulf/Russell/noyoucanthaveaneuralnetwork.jpg
07:33:11 <Slereah> Hm. For the input ASCII -> Church numerals, what would be the best idea?
07:33:54 <Slereah> Just a correspondance number -> church numerals, or number->succ(succ(succ(...succ(KI)....)))?
07:37:58 <Slereah> I guess it's space against time.
07:45:53 <oerjan> succ(succ(...)) is easier to build up recursively
07:46:38 <oerjan> in case you need to use a table, like in unlambda
07:48:31 <Slereah> Yes, but won't it blow up for big numbers?
07:48:39 <Slereah> Lazy K seems to use such a table.
07:50:59 <oerjan> lazy K uses church numerals for I/O
07:51:41 <oerjan> you mean input in decimal digits?
07:53:07 <oerjan> the table will be somewhat big i guess
07:53:26 <oerjan> do you use ?x input like unlambda?
07:54:08 <oerjan> you don't really need all the numbers in a table
07:54:12 <Slereah> Just a _ combinator that will change into the Church integer.
07:54:48 <oerjan> oh so you do input ascii as church numerals
07:55:16 <oerjan> so your question is not about how to use it, but what python should send into the program
07:56:50 <oerjan> adding 1 and multiplying by 2 should be simple enough
07:57:37 <oerjan> it might still get blown up when the program tries to analyze it, i suspect
07:58:58 <Slereah> Well, Lazy K has a table of ways to get short ASCII -> Church
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:02:05 <Slereah> Hm. apparently, plenty of them have the combinator ``s`ksk
08:25:35 -!- oerjan has quit ("Bye").
10:14:31 -!- Hiato has joined.
10:15:02 <Hiato> Can anyone help me with some Haskell quickly?
10:17:33 <Hiato> show map Char.isLower "aBCde"
10:18:02 <Hiato> would that produce [True,False,False,True,True]?
10:23:27 -!- Hiato has left (?).
11:56:22 -!- timotiis has joined.
11:56:53 -!- faxathisia has quit ("Leaving").
12:15:16 -!- RedDak has joined.
12:33:05 <Slereah> I think I'll just define the input as succ(succ(succ(...succ(KI)....)))
12:49:33 <Slereah> But then again, the succ idea is painfully slow!
13:10:32 -!- jix has joined.
13:30:55 -!- sebbu2 has joined.
13:43:41 -!- sebbu has quit (Read error: 110 (Connection timed out)).
13:43:42 -!- sebbu2 has changed nick to sebbu.
13:56:15 -!- bsmntbombdood has quit (Read error: 110 (Connection timed out)).
13:57:11 -!- bsmntbombdood has joined.
14:24:37 -!- Hiato has joined.
14:27:01 <Hiato> can anyone help me with a Haskell exercise in Yet Another Haskell Tutorial?
14:30:10 -!- lifthrasiir has quit (Read error: 104 (Connection reset by peer)).
14:30:57 <Hiato> "Exercise 3.5 We’ve seen how to calculate sums and products using folding functions.Given that the function max returns the maximum of two numbers, write a function using a fold that will return the maximum value in a list (and zero if the list is empty). So, when applied to [5,10,2,8,1] it will return 10. Assume that the values in the list are always ≥ 0. Explain to yourself why it works."
14:31:17 <Hiato> but I guess I should check out #Haskell
14:31:27 <oklopol> i assumed i actually wouldn't be able to do it, but that's trivial )
14:31:49 <Hiato> I just don't get what the folds will need to do
14:31:54 <Hiato> but could you explain?
14:32:04 <oklopol> you have a list A B C D E .. Z, and you need the max. basically, a max takes two values and returns the maximum of the two
14:32:25 <oklopol> because max is... i lack terms :-)... it does A m B = B m A
14:32:37 <oklopol> and all the other funny features like that
14:32:43 <oklopol> you can just do the maxes in any order
14:33:02 <oklopol> so... A B C -> A (B C) -> (A B C) would be a way to get the max of A B and C
14:33:12 <oklopol> fold takes a list, and a function
14:33:26 <oklopol> it then takes a certain pair of values in the list, and performs the operation
14:33:41 <oklopol> then, it takes that pair, and performs the operator on that pair, and another value in the list
14:33:55 <oklopol> on a related note, i think i need to poo ->
14:34:05 <Hiato> foldr (max) 0 [balh]?
14:34:13 <Hiato> lol, sure, er... don't let me stop you
14:34:26 <oklopol> except you don't need the parens
14:35:54 <Hiato> but why does it say you need two folds?
14:36:46 <Hiato> and is the fold direction important?
14:37:29 <Hiato> nevermind, it says a fold
14:37:37 <Hiato> still, is the direction relevant?
14:38:15 -!- slereah_ has joined.
14:50:10 <oklopol> and cmp is "compare these with yer braines"
14:52:59 <oklopol> (A m (B m C)) cmp ((A m )B m C)
14:53:10 <oklopol> (A m (B m C)) cmp ((A m B) m C)
14:53:43 <oklopol> now, take your brain, stuff that in, wait a mo, tell it to generalize, wait a mo, and hope for the best
14:55:13 <Hiato> for the lack of a better word
14:55:16 <oklopol> the max-function is a socalled "bag" function
14:55:26 <oklopol> meaning it conceptually takes a *set* of arguments
14:55:27 -!- Jontte has joined.
14:55:33 <oklopol> you can give it's args in any order that is.
14:55:55 -!- Slereah has quit (Read error: 110 (Connection timed out)).
14:56:05 <oklopol> and of course set operations except set substraction.
14:56:09 <Hiato> (*=X=times=multiplication)
14:56:39 <Hiato> meh, I'll continue with the tut some other itme
14:56:39 <oklopol> that is a helpful thing to know about a function, or not
14:56:48 <oklopol> i just wanted to coin a term for it
14:57:08 <Hiato> as in Heh as in laughter ;)
14:57:54 <Hiato> Haskell is exactly like ad-maths class
14:57:59 <Hiato> piece wise functions
14:58:01 <oklopol> i actually guessed what you meant there! :)
14:58:50 <oklopol> i've actually been wanting to make a language with a type system for a long time... could have my dream of having a language where args are given in arbitrary order come true
14:58:58 <oklopol> basically, the only list would be the set
14:59:10 <oklopol> and you could only give unary args
14:59:11 <Hiato> that would be cool, but also, confusing :)
14:59:40 <oklopol> no no! basically you'd have a distinct type for everything, how ELEGANT!
15:00:03 <oklopol> lol... lisp with sets instead of lists xD
15:00:09 <Hiato> Ah, yes well if Char is Different from String which is Different from Array of Char
15:00:33 <Hiato> it might be aweosme
15:00:34 <oklopol> oh, no, that's not enough...
15:01:00 <oklopol> you need to make a LeftAppendor object and a RightAppendor object
15:01:20 <Hiato> annoying, painful, stupid - but awesome
15:02:02 <oklopol> i've been thinking i could take all these millions of stupid features i'd concocted over the years, remove them from oklotalk and make a new language for them
15:02:17 <oklopol> i mean, that's sometimes pretty nice
15:02:39 <oklopol> like, you wanna have the program in the form oper func oper func oper func etc
15:02:43 <Hiato> Well, I don't really mind, as long as we get to _eventually_ see the langauge
15:02:55 <oklopol> because then you don't need parens then.
15:03:01 <Hiato> that would be cool, yip
15:03:18 <oklopol> now, if types make up the order of usage of argumens
15:03:40 <oklopol> then you can almost always have execution be linear if it's conceptually linear
15:03:44 <oklopol> if you know what i mean...
15:04:00 <Hiato> I think I get it...
15:04:12 <Hiato> but im not too sure
15:04:19 <Hiato> talking about flow control??
15:04:21 <oklopol> i'll try and find a weird example
15:04:34 <Hiato> then I get what yoyu are saying
15:04:45 <Hiato> in a twisted kind of abstract sense...
15:04:52 <oklopol> okay, very stupid example, but anyway
15:05:35 <oklopol> let's say you wanna do "A - (B - C)", but don't want the parens...
15:06:16 <Hiato> makes programming truly painful :P
15:06:16 <oklopol> OH, C IS AN LPARAM, THEN THE OTHER MUST BE RPARAM!
15:06:39 <Hiato> good luck with the interpreter though
15:06:55 <Hiato> trying to make it run in linear time :X
15:07:10 <oklopol> hehe, actually i'd just really like to do static typing, so this might be a nice thingie to test with.
15:07:26 <oklopol> i've always had either dynamic or brainfuck typing
15:07:36 <oklopol> (where everything is statically a number...)
15:08:16 <Hiato> http://esoteric.voxelperfect.net/wiki/Betterave
15:08:25 <Hiato> But, unlike these three languages, it is not tape- nor stack-based. Instead, programs are written as expressions. Like Scheme, it has a prefix notation, but unlike Scheme, there are no parentheses; each operator knows how many arguments must follow it. Thus, for example, the parameters of an addition come after the "+" symbol.
15:08:28 <oklopol> yeah, it runs everything in linear time, of course... hmm, i think static typing isn't the hard part anymore
15:08:59 <oklopol> 1. that's completely different 2. i had that idea 3 years ago
15:09:03 <Hiato> it's nearly everything you were o about
15:09:04 <oklopol> and thought it was original
15:09:16 <oklopol> it's called "polish notation", i learned then
15:09:26 <oklopol> oh, no, that's polish notation.
15:09:35 <oklopol> false is rpn, reverse polish notation
15:09:50 <Hiato> lol, we both realised
15:09:56 <oklopol> stack-based, you might say
15:09:59 <Hiato> it took me 2 seconds longer :P
15:10:06 <Hiato> (5:09:58 PM) oklopol: false is rpn, reverse polish notation
15:10:07 <Hiato> (5:10:00 PM) Hiato: FALSE is rpn
15:11:44 <oklopol> 1. that's completely different. 2. i had that idea. 3. years ago, when i was in lapland, i saw a reindeer eat its own shit
15:12:21 <Hiato> haha, Must have been a truly inspiring sight
15:12:35 <oklopol> oh, sorry, that's not true, i just added something :)
15:13:02 <Hiato> oh I see, so what you meant is: 1. i had that idea. 3 years ago, when i was in lapland, i saw a reindeer eat its own shit ?
15:13:05 <oklopol> i mainly ogled at girls last time i was in lapland :)
15:13:25 <Hiato> unsurprisingly, I am not surpirised
15:13:32 <Hiato> and that is a helathy habbit nontheless
15:13:40 <oklopol> no, i wanted to change the "3 years ago" into "part 3. years ago..."
15:13:58 <Hiato> I know, I was merely toying with you mortal mid
15:14:09 <oklopol> and in that you did succeed!
15:14:30 <oklopol> oh, btw, i played a bit with the idea of pattern matching
15:14:53 <oklopol> sofar, quicksort looks unbelievably weird, but i found comfort in that the prolog one i found is very similar :D
15:15:14 <oklopol> i thought i had the world's stupidest and ugliest idea ever when i invented scramble
15:15:24 <oklopol> the function that randomly scrambles a list
15:15:47 <Hiato> It turned into OgroSort (random sorting)
15:15:54 <oklopol> prolog has "perm", i then found out
15:16:08 <oklopol> and permutation is just fancy talk for scrambling :)
15:16:11 <Hiato> I wrote a permuatation algortihm once
15:16:31 <Hiato> and permutation is just fancy talk for scrambling :) ... er sure
15:16:37 <oklopol> oh, i'm not even disappointed anymore when i found my ideas already in use,
15:16:55 <Hiato> what a horrible and demaning experience
15:17:08 <Hiato> to kill kittens unless I was credited
15:17:19 <oklopol> and i usually found out about them right after i've invented them (usually because of my own googling, but often also by randomly looking at #haskell or somethign)
15:17:51 <oklopol> i actually then renamed Scramble into Perm
15:18:23 <Hiato> http://rafb.net/p/jRzJ6635.txt
15:18:25 <oklopol> which is kinda lame because i'm trying to keep the concepts of pattern matching and constraint programming separate :P
15:18:32 <oklopol> or is it logic programming...
15:18:45 <Hiato> I don't have the faintest clue
15:19:27 <Hiato> That's a perfect demonstration of my horrible procedural style
15:19:41 <Hiato> which is why I want to become proficient in functional languages
15:21:34 <oklopol> well, i don't get all of that
15:21:50 <Hiato> well grab FPC or something
15:21:54 <Hiato> and Permute away :P
15:22:05 <Hiato> FPC = Free Pascal Compiler
15:22:14 <Hiato> which is what Lazarus IDE is
15:22:34 <Hiato> that's besides the point
15:22:38 <Hiato> the point is the style
15:22:45 <oklopol> for k := 0 to sizeof(p)-1 do if PosRightGreater(k) then maxp := k;
15:22:54 <oklopol> ...does that find the max of a list?
15:23:13 <Hiato> finds the furthest possible number from the left hand side
15:23:20 <Hiato> which has a number graeter than it on it's right
15:24:48 <oklopol> i think that's quite a slow way to do it...
15:24:55 <Hiato> it's the only way I could think of...
15:25:01 <Hiato> but you are correct
15:25:19 <Hiato> fast, but slow in terms of cycles per permuttation
15:25:38 <Hiato> it takes about 0.5 secs to rubn through 8! permuataions, I think
15:27:15 <oklopol> oh, right, just iterate from right to left, store the first number as max, and when you find a number > max, return the index of that
15:27:36 <oklopol> just first because started from the end...
15:28:03 <Hiato> but that won't be in lexicographical order
15:28:32 <oklopol> that will find the last index in the list for which there are no greater numbers on the left
15:29:13 -!- jix has quit (Read error: 60 (Operation timed out)).
15:29:42 -!- jix has joined.
15:29:42 <Hiato> I think that that won't be too much faster than what I am doing
15:29:45 <oklopol> let's say you have [9 5 6 8], store 8 as max, then go until you find a number greater than it
15:30:01 <oklopol> like this you go through half the list
15:30:11 <Hiato> yes, I do start on the left
15:30:13 <oklopol> your way you go through the list for every element of the list
15:30:30 <oklopol> mine is O(n), yours O(n^2), unless i read the code entirely wrong
15:30:50 <Hiato> yes, it's definitely not linera
15:31:35 <Hiato> then that will be wrong
15:31:49 <Hiato> it should, return, in this example
15:31:57 <Hiato> as 5 has something to its right
15:32:02 <oklopol> but do you see the connection between the algos?
15:32:45 <oklopol> my algo finds the last number that does *not* have a greater number on its right
15:33:02 <oklopol> now, every number after it in the list will have a certain property
15:33:16 <Hiato> a number graeter than it on it's right
15:33:27 <oklopol> do you see the connection?
15:33:31 <Hiato> but that still is one step away
15:33:38 <oklopol> it is so trivial i didn't consider them a separate algo at all.
15:33:46 <Hiato> I still need the largest possible number
15:34:35 <Hiato> not he largest possible
15:34:36 <oklopol> you see i have no idea what you are doing with this since i haven't read the code, i'm just telling you the best algo to do what you explained :)
15:34:39 <Hiato> the furthest possible
15:35:05 <Hiato> that everything save 8
15:35:18 <Hiato> is valid in the 9 5 6 8
15:35:41 <Hiato> so, I guess I can just chosser the one before it
15:35:49 <Hiato> valid = something greater on it's right
15:36:00 <oklopol> then it won't be the leftmost.
15:36:19 <oklopol> indeed, mine doesn't quite solve it ;)
15:36:24 <oklopol> but, it's a trivial change.
15:36:30 <Hiato> the problem is rightmost
15:36:36 <Hiato> and your's would report 9
15:36:47 <oklopol> you want the rightmost? :D
15:37:03 <oklopol> oh, in that case, it even simpler than my original one
15:37:32 <Hiato> (5:36:11 PM) Hiato: valid = something greater on it's right
15:37:38 <oklopol> take the last of the list, go to the left unless the new number is smaller than the last number
15:37:53 <Hiato> that would be way easier
15:38:27 <Hiato> that would yield false results
15:38:45 <Hiato> we would stop on 8
15:39:16 <Hiato> then we have another problem
15:39:38 <Hiato> which is not part of the condition
15:39:52 <oklopol> at 6, the new number (6) is smaller than the last number (8)
15:40:16 <Hiato> that will decrease the CPU cycles
15:40:37 <Hiato> I just then have to change the code a bit
15:40:42 <Hiato> to say if it is the 1st number
15:40:50 <oklopol> it's a big algorithmic improvement, i recommend you read a bit about complexities in general
15:40:52 <Hiato> instead of if PosRightGreater returns false
15:41:02 <Hiato> yes, I would like to
15:41:38 <oklopol> since i'm fairly sure i'd've lolled my ass off if i didn't know who you are :)
15:41:51 <oklopol> programmers are sometimes like that
15:42:07 <oklopol> i mean, if i'd just seen that algo on the net
15:42:10 <Hiato> I'm not sure whether to take that as a compliment or insult
15:42:25 <Hiato> yes, if you'd have seen it on the net
15:42:39 <oklopol> i mean, without knowing whose it is.
15:42:49 <Hiato> yes (I'm listening :P )
15:42:54 -!- RedDak has quit (Remote closed the connection).
15:42:57 <Hiato> (no worries, I won't take offense)
15:43:05 <Hiato> (it was stupid ;) )
15:43:55 <oklopol> it's just you get a bit obsessed about complexities after being around them constantly
15:44:19 <Hiato> what is it that you do?
15:44:21 <oklopol> an algorithm that obviously does what it does inefficiently is actually very funny after that.
15:44:40 <Hiato> Hehe, I can see where you're coming from
15:44:53 <Hiato> if you don't mind my previous question
15:45:02 <Hiato> would you answer it ;)
15:45:10 <oklopol> sometimes also because a tabsize of 8 instead of 4 is enough, though, people are pretty obsessed with prettiness of code too :)
15:45:45 <Hiato> "people are pretty obsessed with prettiness of code too :)" unfortunately true
15:45:57 <Hiato> what is it that you do?
15:46:02 <Hiato> for a living, or whatever?
15:46:36 <oklopol> oh, i'm in high school, possibly failing it, taking a few courses from the uni on the side
15:47:04 <oklopol> they just let me on one course at a time :-(
15:47:06 <Hiato> well, im not sure about failing (:P) or courses
15:47:25 <Hiato> I have my sincere doubts that you are failing :)
15:47:41 <oklopol> well, after the first few weeks of high school i realized it has nothing to offer me (or anyone non retard.)
15:47:51 <oklopol> so... haven't really done anything there.
15:47:57 <oklopol> i lack a few courses i should have
15:47:58 <Hiato> Hahah, so very (sadly) true :)
15:48:28 <Hiato> I go to school, to come home
15:48:33 <Hiato> it's that simple :)
15:49:08 <oklopol> i don't really go, since i have 4 hours of lectures a week
15:49:17 <oklopol> no courses in high school anymore, just the one course in cs
15:50:14 <oklopol> basically, a course about heaps.
15:50:55 <oklopol> different ways to keep them balanced, stuff you could explain in a few lines for those who've never heard about them :)
15:51:25 <oklopol> i've actually done this, a whole course about ordos, i taught them to a friend in a few nights.
15:52:02 <Hiato> http://rafb.net/p/0YrGtq15.txt
15:52:23 <Hiato> its way smaller now
15:53:43 <Hiato> got to do some stuff
15:53:46 -!- Hiato has left (?).
15:54:26 <oklopol> people can be so weird... leaving irc...
16:20:00 <oklopol> what's the shortest brainfuck interpreter in a language not spesifically designed for brianfuck?
16:20:30 <oklopol> and by specific design i mean stuff like a language that executes brainfuck code.
16:40:19 -!- oklopol has quit ("for the need to encumber").
16:47:25 -!- oklopol has joined.
17:00:57 -!- oerjan has joined.
17:17:49 -!- ehird` has joined.
17:21:44 -!- helios24_ has joined.
17:21:58 -!- helios24 has quit (Read error: 113 (No route to host)).
17:24:37 -!- Hiato has joined.
17:25:24 <oklopol> no thanks, but it is a bit chili outside.
17:25:47 <oerjan> oklopol: no fair, i was going to...
17:25:52 <oklopol> (finally, a chance to pun-answer that)
17:26:08 <Hiato> Souther Hemisphere - Oh Yeah :D
17:26:17 <oerjan> although i did it a previous time so...
17:26:51 <oklopol> i read all teh logs, although i usually skip the long discussions over debugging something :D
17:27:11 <Hiato> Hah, I also try to
17:27:21 <oklopol> well not skip, but not read memorizingly
17:27:25 <Hiato> whenever I go to slleep
17:27:39 <Hiato> I'm garunteed to miss out on the *actual*
17:27:59 <Hiato> yes, well I just do Ctlr+F
17:28:06 <oerjan> ah yes. how come you started asking haskell questions just when i left ;)
17:28:21 <Hiato> Couldn't help it :)
17:28:29 <Hiato> That's when the exercises got hard in the tut
17:28:44 <oerjan> although oklopol handled that well :)
17:28:55 <oklopol> thanks, i thought so too :P
17:29:11 <Hiato> Yes, I must hand it to him: Oklopol, you taught me folds in ~3 lines, and the whole tut didn't make sense (about them)
17:29:33 <oklopol> i couldn't add the insightful "BUT, you can also do that with a StateT monad, and it's much COOLER" oerjan could've added!
17:29:54 <oklopol> (not would've, but could've)
17:30:28 <oerjan> no, State is sufficent ;)
17:30:35 <oklopol> i'm not sure what a monad would have to do with a fold, but i'm fairly sure you can put a bit of monad to everything :-)
17:30:52 <Hiato> sure, whatever floats your boat oklopol :P
17:31:17 <Hiato> well that explains everything
17:31:25 <ehird`> someone should write a haskell fibonacci that uses just monads
17:31:27 <Hiato> pulling your leg(s)
17:31:38 <oerjan> or actually... nearly anything you do with lists will be essentially folds at the bottom anyhow, even if you use monad functions
17:32:11 <oklopol> (from the little understanding i have about the subject)
17:32:17 <Hiato> sure (desperately searches the tutorial for what monads are)
17:32:30 <oerjan> Hiato: they may have left that out out of mercy ;)
17:32:49 <oklopol> Hiato: yeah, quickly look them up so you can have a conversation about them :)
17:32:53 <Hiato> in which case: I'm not interested :P
17:33:28 <oerjan> actually you must have at least one monad eventually: IO to do I/O
17:33:49 <oklopol> "monad? i'll check wikipedia" *minute* "ah, now i see what you meant by that seven lines of monadic line noise"
17:34:23 <Hiato> Yes.. er.. no... am... maybe
17:34:32 <Hiato> choose the more appropriate one
17:35:03 <oklopol> oklopol: chooses "am", for he is such an egois.
17:35:27 * oerjan wonders if t means something in finnish
17:35:32 <oklopol> FUCK, i'm failing a bit too much heree..
17:35:54 <oklopol> oerjan: @, or "at" is pronounced "ät"
17:36:19 <oklopol> although you rarely see it in use as such, since it looks awful, that's what "ät" would mean
17:36:24 * Hiato wonders if "/me" will come out right
17:36:47 <oerjan> well that's just borrowing english pronunciation i take
17:37:06 <Hiato> Watter taal praat jy oklopol?
17:37:21 <oklopol> "what language do you speak?"=
17:37:32 <Hiato> and the winner is....
17:37:38 <oklopol> i remember praat and jy from yesterday
17:37:43 <oklopol> so... shouldn't have had to ask.
17:38:00 * oerjan actually got that since "prat" is norwegian too
17:38:05 <Hiato> Dutch I take it....
17:38:13 <oklopol> well it's sprache in german and prata is talk in swedish, it's not like it's hard to remember something you almost remember already
17:38:14 <Hiato> or is memory failing
17:38:23 <oerjan> almost certainly borrowed from dutch though
17:38:40 <Hiato> ah yes, we went through this yesterday :P
17:38:44 <oklopol> well, i use english more, but finnish is my native language
17:38:53 * oerjan has read that the only native word starting with in norwegian is "p"
17:39:05 <Hiato> Afrikaans = 90% Duthc + 5% English + 5%Randomness
17:39:42 <Hiato> because every time you learn a rule
17:39:54 <Hiato> there are more exceptions then are things that confomr :(
17:40:35 <oklopol> all i know about dutch is from porn
17:40:38 <oerjan> ah, just like english then :D
17:41:03 <Hiato> took me years to learn English
17:41:07 <oklopol> they make very sucky erotic comedies.
17:41:31 <Hiato> I'll take it you're the expert
17:41:49 <oklopol> i can't really think of anything funnier than an ugly guy having sex with three girls in fast motion with carneval music on the background :)
17:42:11 <Hiato> yes, well Dutch pron that is
17:42:22 <oklopol> oh, well probably any kind
17:42:43 <Hiato> http://esoteric.voxelperfect.net/wiki/2006_Esolang_Contest
17:42:57 <Hiato> there is no way 3/4 of the Esolangs out ther
17:43:05 <Hiato> can do any of "The Tasks"
17:43:14 <Hiato> someone weas on something real good :)
17:43:58 <oerjan> oh they _can_, if they're turing complete
17:44:13 <Hiato> treu, but you know what I meant
17:44:35 <oerjan> i mean, _someone_ wrote a mandelbrot generator in bf...
17:44:45 <Hiato> No single human (or multiple humans) has/have the capacity to concentrate for a long enough period of time
17:45:07 <Hiato> It's not hard really
17:45:12 <Hiato> at least the maths part
17:45:12 <timotiis> nonsense. first, write the program for a turing machine, secondly, implement the turing machine in language of choice
17:45:17 <Hiato> I did one in ruby easily
17:45:32 <oklopol> timotiis: now that you put it that way, can't think of anything simpler.
17:46:11 <oerjan> as i recall, a mandelbrot in basic was one of the first programs i ever wrote, long long ago
17:46:15 <Hiato> is Pikhq the resident Brainfuck god?
17:46:54 <oklopol> pikhq is the author of pebble, i'm assuming he owns at brainfuck, although i don't know what he's done with it
17:47:09 <oklopol> also, i know he's said "brainfuck is easy once you've used it a bit"
17:47:16 <oklopol> not in those words, but something along those line
17:47:30 <Hiato> Lunacy I tell you :P
17:47:37 <Hiato> http://rafb.net/p/OXHki823.html
17:47:41 <oklopol> well, it's true, it's not that hard ;)
17:47:51 <oerjan> hm i think the uuencode task might be the simplest...
17:48:04 <Hiato> im not sure though
17:48:13 <Hiato> sed is definitely difficult
17:48:19 <Hiato> in non-stringy languages
17:55:20 <Hiato> Wise man once say: "Mandelbrot Set make IRC silent, Phoenix set make noise"
17:56:16 <oerjan> what is the Phoenix set?
17:56:28 <Hiato> its alos an infintely repeating set
17:56:38 <Hiato> let me get the link
17:58:06 <Hiato> http://www.jamesh.id.au/fractals/mandel/Phoenix.html
18:00:48 <Hiato> not pretty, hence it makes noise :P
18:02:46 <oklopol> interesting note: "aye" means "no" in finnish
18:02:52 <oklopol> although it's written "ei"
18:03:01 <Hiato> I learnt some finnish
18:03:09 <oklopol> interesting note: "aye" means "egg" in german, although it's spelled "ei"
18:03:24 <Hiato> heh, and some german
18:03:37 <oklopol> it's not pronounced the same, i failed :)
18:03:52 <oerjan> (i.e. ei means "not" in norwegian, although it's a bit rare)
18:04:19 <oklopol> Hiato: i'm not sure how to type how it's pronounced in finnish in english...
18:05:18 <Hiato> I won't remmeber half of these, but cool nonetheless
18:05:40 <oklopol> "kule" pronounced a bit like "dune" and then "la" as in the beginning of "lag"
18:06:20 <Hiato> I think I get it though :)
18:07:06 <oklopol> you can't really explain the exact pronunciation like that, since everything is pronounced a bit differently
18:07:22 <Hiato> cool, thanks nonetheless
18:07:35 <Hiato> well, not right back but hey
18:35:44 -!- calamari has joined.
18:38:26 <pikhq> oklopol: I've done a small amount of things in Brainfuck, yes.
18:40:14 <oklopol> you yourself have said dbc is the guru, i think. this is why i had no trouble putting him above you in the brainfuck-capability meter i have in my head
18:40:36 <oklopol> i used to be pretty good myself..
18:40:55 <oklopol> a million years ago, when i was able to program in other languages than python.-
18:41:46 <Hiato> I think I caught Eso-fever
18:42:10 <Hiato> I already want to make a new language, and I haven't even named the current one :(
18:44:33 <Hiato> Doctor, is it curable?
18:55:33 <pikhq> However, with longterm treatment, it can be managed.
18:55:45 <pikhq> (side effects include severe geekiness_
19:00:12 <Hiato> Alright, I need some _community_ (winces) suggestions for a name for my esolang so that I can write an interpreter and not feel guilty about thinking about my next one
19:00:26 <Hiato> its the funky obfuscated one
19:00:56 <Hiato> where helloworld is : {{>>~~~~{-<}~~~~~~~~~{-<-<}<<}</(<<<){[<]}:>:{>>{~~~~~~~~{<}~{>}}<<}\ ~>{{~{v}}>>>v{~}^<<<}/(<<<){[<<]}:>:{>>{~~~~~~~~{<<}~{>>}}<<}\ ~{>>{vvvvvvvv~~~~~~~~~~~~~~~}<<}~{>>{vvvv~~~~~~~~~~~~~}<<}~ {>>{^^^^^^^^^^~}<<}~{>>{v~~~~~~~{{<<}~}v{~}vvvvvvv{~{>>}}^^^^^^~~~ {{<<}~}vvvv{~{>>}}v~~~}<<}~<{{^^^}}~{>>{vvvvvv~{{<<}~{>>}}^^^^^^^~~~~~~~~~~~{{<<}~{v>}}^^^^^^}}/{{()}}{[<<<<]}:>:{{~v}}\}
19:01:20 <Hiato> and outputting T using Fibonacci is: {{>>}~~~~~~~~~~~{{-<~}<<} /{{(<){[<<]}}}:>:~{>>{<<}}~{<<{>>~<<}>>}~{<<{>>}}\{>>v}~{^}~~~~~{<}~ {<{~}v>}~}
19:02:21 * Hiato wonders if ever anyone will respond, appropriately
19:06:45 <Hiato> Nice name, does it mean anything?
19:07:11 <pikhq> It's the outer ring of the 7th level of hell in /The Divine Comedy/.
19:07:24 <pikhq> The naming, obviously, inspired by Malbolge.
19:07:49 <Hiato> though this is actually _possible_ to programme in, well just
19:08:19 <Hiato> in the absence of any other suggestions
19:08:28 <pikhq> The 7th level of hell is reserved for those violent against people and property.
19:08:34 <Hiato> and it will now be processed
19:08:38 <pikhq> Which you will be after coding in that. :p
19:09:12 <Hiato> (Even though in my religion, there is no hell, but hey ;) )
19:09:29 <Hiato> it has a nice ring to it
19:10:00 * Hiato contemplates naming it Plegethon 2, to suggest some kind of advancement
19:13:12 <Hiato> something less...er for the lack of a better word, evil
19:14:07 <Hiato> like Fluffy Bunny Esolang :P
19:19:11 <pikhq> Generic evil: Inferno.
19:21:16 <Hiato> I dub the language Inferno
19:21:32 <Hiato> for no apparent reason too ;)
19:33:29 -!- oerjan has quit ("Coffee").
19:48:41 <Hiato> inferno exists? or call it exists. I'm confused...
19:48:58 <ehird`> a language named that exists
19:49:04 <ehird`> well an os named that with a language called limbo
19:49:11 <Hiato> ok, undo the dub process
19:49:26 <Hiato> oh yeah, I think I even heard of it
19:50:01 <ehird`> http://en.wikipedia.org/wiki/Limbo_programming_language quite clean code actually
19:50:49 <Hiato> ok, so any suggestion s for a new name?
20:08:37 <Hiato> what about Citizen II
20:09:51 <ehird`> name for the language LEMON that's all for now
20:10:04 <Hiato> sorry, I dpnt speak fruit
20:10:49 <Hiato> ehird` : would you so kindly explain what that was about, feel free to decline ;)
20:11:03 <ehird`> nftlLEMONtafn is what you should call your language
20:11:14 <ehird`> standing for: "name of the languge LEMON that's all for now"
20:11:55 <Hiato> am.. thank you for your.. err.. generous contribution, we value all of our customers equally, please hold
20:12:22 <Hiato> I felt inspired too :P
20:14:54 <ehird`> come on, esoteric names for esoteric languages
20:15:17 <Hiato> well, I think the LEMON one was a bit too far away from anywhere, really
20:15:22 <Hiato> I don't mind changing the name
20:15:29 <Hiato> but not to that ;)
20:16:10 <Hiato> actually, I quite like just notlLEMON
20:16:27 <Hiato> as in name of the language (is) LEMON
20:17:17 <oklopol> give it a mutable name global between each interpreter for it
20:17:21 <ehird`> nftlLEMONtafn is good though
20:17:25 <oklopol> and add a few command to change the name
20:18:12 <Hiato> not sure I'm with you oklopol... ehird` the stuff after lemon looks kind of stupid though
20:19:42 <Hiato> rather how's about just LEMON
20:20:33 <oklopol> Hiato: not with me as in don't agree that'd be awesome, or didn't understand what i meant?
20:21:13 <Hiato> well, really the whole thing, but yes, mutable
20:21:13 <oklopol> if something is mutable that means you can change it.
20:21:32 <Hiato> so what is the interchangeable global?
20:21:37 <Hiato> and what should it do
20:21:49 <Hiato> interchangeable=mutable (methinks)
20:23:09 <Hiato> what do you mean " give it a mutable name global between each interpreter for it"
20:27:34 <oklopol> basically, that the name of the language could be changed by a primitive in your language.
20:27:34 <Hiato> Hah, im not even so sure you knew what you meant :P
20:27:53 <oklopol> no, it's not nice, but it's an idea :)
20:28:11 <Hiato> no, it is nice, because (I say so :P ) I like it :)
20:28:30 <oklopol> haha, well, the problem is it's a bit hard to implement :D
20:28:41 <Hiato> Oh yeah, you got that right :D
20:28:43 <oklopol> it could change the name on the wiki page xD
20:28:54 <Hiato> but I would need PSOX
20:28:58 <oklopol> well, actually would have to move the page to another location :D
20:29:04 * Hiato waits for SGEO to storm in...
20:29:22 <oklopol> should a language with the new name already exist, it would just give a runtime error.
20:29:24 <Hiato> ok log in->create a page with the template
20:29:30 <Hiato> and then update the name part
20:29:44 <Hiato> Runtime error... amm 404 :P
20:30:04 <oklopol> and for starters you can name it The Language That Changes Its Own Name
20:30:23 <Hiato> but then voxelperfect would die
20:30:33 <Hiato> because everyone would execute progs
20:30:47 <Hiato> to see if "it lives up to its name"
20:31:32 <Hiato> currently though, it's LEMON
20:31:43 <Hiato> until further notice ;)
20:40:02 <ehird`> lemon is a parser generator, qutie common
20:40:10 <ehird`> and its accompaning input language
20:40:25 <ehird`> nftlLEMONtafn isn't taken!
20:43:29 -!- pikhq has quit (Read error: 110 (Connection timed out)).
20:47:55 <ehird`> Language Eminating Monstrous Ontologies: nftlLEMONtafn
20:48:12 <ehird`> nftlLEMONtafn = name of the language LEMON that's all for now
20:48:21 <ehird`> LEMON = Language Eminating Monstrous Ontologies: nftlLEMONtafn
20:49:48 <Hiato> you have convinced me
20:50:35 -!- Tritonio_ has joined.
20:53:05 <Hiato> Ontology is a study of conceptions of reality and the nature of being.
20:55:42 <Hiato> though, if LEMON is taken, perhaps it would be better not to have it form part of the name
20:56:15 <Tritonio_> hello everyone and happy new year!
20:56:46 <Hiato> and happy new year to you to
20:57:02 <Hiato> (even though today is the 6th for me :P )
20:58:33 <oklopol> Hiato: you see Tritonio_ lives a few trips around the world away from you
20:58:41 <oklopol> he's just celebrating new years'
20:59:14 <Hiato> No way, but hehe anyway
20:59:28 -!- pikhq has joined.
21:03:40 <Hiato> what about this for the name:
21:03:41 <Hiato> TEPLTIAOAUHAUA (The Esoteric Programming Language That Is Absurdly Obfuscated And Unfortunately Has An Unpronouncable Acronym)
21:04:02 <ehird`> unpronouncable acronym rips on INTERCAL (Language With No Pronouncable Acronym)
21:04:16 <Hiato> even though I just though of it
21:04:24 <Hiato> ok, well, Ill try again
21:05:03 <Hiato> actually (believe it or not) I'm glad ehird` is looking out for these things, otherwise this language would be cheap. Thanks :)
21:05:36 <Hiato> Should I go the funky Acronym route?
21:06:17 <Hiato> BLAH (This is not an acronym for the language)
21:06:32 <Hiato> or BLAH (Not An Acronym For the Language)
21:07:36 <Hiato> BLAH (Blatently Lazy Acronym, Hey?)
21:10:35 <ehird`> call it: ACRONYM, Recursive (Languge Without Self-Reference In The Name)
21:13:53 <Hiato> NCTOAN (Nope, Couldn't Think Of A Name)
21:14:22 -!- Tritonio_ has quit (Read error: 104 (Connection reset by peer)).
21:14:42 <Hiato> N/A (Not Applicable and Non-Acronym)
21:18:55 <Hiato> congratulations and thank you :D :D
21:19:03 <Hiato> I like ACRONYM very much :D
21:19:59 <timotiis> "You have a doomsday device? You have a doomsday device and you didn't tell me?"
21:20:02 <timotiis> "Frank! Frank, Frank. Boss. Of course I have a doomsday device. What do I look like, a sane person?"
21:20:14 <ehird`> timotiis: sam hughes!!!
21:22:18 <ehird`> i found him on freenode once
21:22:29 <ehird`> i think his nick was rashakil or similar
21:32:07 -!- jix has quit ("CommandQ").
21:33:06 -!- Jontte has quit ("Konversation terminated!").
21:41:03 -!- Tritonio_ has joined.
21:41:14 -!- Tritonio_ has quit (Read error: 104 (Connection reset by peer)).
21:48:56 -!- calamari has quit ("Leaving").
21:55:23 <Hiato> I like the angle of incidence 1l, why was it abandoned
21:55:37 <Hiato> don't make me take it onto myself to complete.....
22:10:31 <Hiato> Well, I finished th spec for 1L_AOI
22:12:21 <Hiato> http://rafb.net/p/VC26oA18.txt
22:15:23 <Hiato> Does anybody know Gregor Richards' email address
22:15:30 <Hiato> I want to contact him
22:16:23 <pikhq> No idea. But he's in the channel.
22:16:32 <pikhq> GregorR: You paying attention to IRC today? :p
22:17:03 <Hiato> I would like you to check out the brief 1L_AOI spec I wrote
22:17:23 <Hiato> give it your blessing and continue the wonderful project that is the 1L language
22:22:49 -!- Aardwolf has joined.
22:28:11 <Hiato> made a mistake in the spec
22:29:06 <Hiato> it would have been impossible to do anything with
22:29:13 <Hiato> because of a catch 22
22:30:08 <Hiato> you need to be moving down to increase something, but in order to move down, you need to increase something, and the original direction was right
22:30:16 <Hiato> thus it would have been impossible :P
22:32:27 <Hiato> ok GregorR and anyone else interested, here is the corrected spec for my idea of 1L_AOI (Angle Of Incidence)
22:32:28 <Hiato> http://rafb.net/p/VMGMTC23.txt
22:33:52 -!- Hiato has quit ("Leaving.").
22:37:04 -!- oerjan has joined.
22:41:41 <slereah_> I should add the i combinator of iota to Lazy Bird.
22:41:48 <slereah_> As an archeopterix or something.
22:44:13 <slereah_> Is the i combinator thusly? ``s``si`ks`kk
22:46:42 <slereah_> Hm. I'm trying to find a simple lambda form, but I'm not sure there's one beside the definition.
22:47:34 <slereah_> Yes, but well, I need a form for the string rewriting.
22:48:10 <oerjan> -> ^x``xsk -> ``s``si`ks`kk
22:48:32 <slereah_> Unfortunately, it seems that ``````...````iabcd...xyz = ````...````askbcdef....xyz
22:49:16 <slereah_> I could rewrite all occurence of the combinator as ``s``si`ks`kk, but well, I'd rather find a quicker method
22:49:59 <oerjan> well the obvious thing is to rewrite `ix as ``xsk
22:54:47 <slereah_> Since it's supposed to be unique, maybe I should switch s and k to their translation.
22:56:36 <oerjan> problem is, you then need to add rules to recognize the translations.
22:57:13 <slereah_> Well, the i combinator will be added to the program itself.
22:58:13 <oerjan> i mean, i = ^x``x`i`i`i`ii`i`i`ii is not enough to define it
22:58:19 <slereah_> The problem is, I'm not sure how it would play out since ``x`i`i`i`ii`i`i`ii uses the combinator itself
22:58:59 <slereah_> Ah, iota defines it just as a lambda expression.
23:01:39 <slereah_> On another matter, I defined _ as replacing it with the ASCII input with s="```s`k`s``s`ksk``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s`k`s`kkk`kk`k`ki"+s
23:02:19 <slereah_> I think I'll have to finish the table, but so far, I didn't even reached A.
23:02:23 -!- timotiis has quit ("leaving").
23:07:27 <slereah_> Thusly : http://membres.lycos.fr/bewulf/Russell/Lazy%20Bird/Church%203.txt
23:08:48 <oerjan> i think 23 is too long, surely you can double and add 1 to the 11 version faster than that
23:10:20 <oerjan> your + is a bit deceptive i think
23:10:54 <oerjan> it assumes passing m and n as arguments, but for constructing numbers you would just put them in directly
23:11:48 <slereah_> Well, that's how I use my addition.
23:11:50 <oerjan> so ``+mn = ^f^x``mf``nfx = ^f``s`k`mf``s`k`nfi
23:12:23 <oerjan> except then it is useless for constructing short numbers
23:12:31 <slereah_> succ *2 11 gives me ``s``s`ksk``s``s`ks``s`k`s`k``s`k``s``s`kski``sb``s``s`ks``s`k`s`k``s`k``sbi``sb``s``s`ks``s`k`s`k``s`k``sbi``sbik`kik`kik`ki
23:12:43 <slereah_> I use the Lazy K table to construct them.
23:13:44 <slereah_> After shortening the 23, I get ``sb``s``s`ks``s`k`s`k``s`k``sbi``sb``s``s`ks``s`k`s`k``s`k``sbi``sb``s``s`ks``s`k`s`k``s`k``sbi``sbik`kik`kik`ki
23:14:44 <slereah_> And ``23.xi prints the right number of x's.
23:15:32 <slereah_> Or simplify to `a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`ax with some dummy combinators.
23:19:15 <oerjan> the most obvious way to make this efficient would be to embed decimal notation...
23:20:22 <oerjan> it would even be possible to define #,0-9 such that ``#102 = church numeral 102 i think
23:20:33 <oerjan> although your 0 is already taken
23:21:11 <oerjan> # = church numeral 0, digit d = multiply by 10, add d
23:21:46 <oerjan> it would have to be written ``201# for that
23:22:54 <slereah_> (I made a Lazy Bird -> SK translator, in case I want it less readable)
23:36:03 -!- calamari has joined.
23:42:49 <ehird`> what's basically the biggest bf program out there?
23:42:54 <ehird`> it's 2mb lostkng.b right?
23:55:06 -!- slereah_ has changed nick to Slereah.
23:56:14 <Slereah> Is a list of the form ``s``si`k[as many as size f the list - 1]``s``si`k[1]`k[2]`k[3][...]`k[n]?
23:56:17 <ehird`> there's an odd shortage of bf->machine code translators
23:56:28 <ehird`> Slereah: i know the lambdacalculus for it
23:57:05 <ehird`> and have NIL := FALSE or similar
23:57:17 <ehird`> maybe have NIL := CONS NIL NIL, with the y-combinator
23:58:05 <Slereah> I suppose CAR-CDR are the take first-second element