00:12:00 -!- uvanta has joined.
00:27:45 <Asztal> should I mark my program as a cheat?
00:27:56 <Asztal> it still rot13s '[', '] and '_'
00:29:03 -!- GreaseMonkey has changed nick to ^_`.
00:32:05 <oerjan> so what does that rot13 to? :)
00:38:30 <Asztal> 51 bytes though, not as good as I expected :(
00:41:00 <ehird> ={:'a'z..?{'a-13+26%}if}<!
00:41:04 <ehird> ninjacode, without much thought
00:41:10 <ehird> so ninjacode 0.000001 prepreprepreprealpha
00:41:15 <ehird> doesn't handle uppercase though.
00:41:19 <ehird> and doesn't even work properly.
00:47:43 <ehird> oerjan: interesting things in that:
00:47:55 <ehird> if its first arg is a block
00:48:01 <ehird> the second should be an array (or string, same thing)
00:48:06 <ehird> then it works as map
00:48:23 <ehird> ! with stack (a b) where both are arrays, a's contents gets destructively replaced with bs and b popped
00:48:30 <ehird> =... is like a perl filter.
00:48:48 <ehird> "for all lines in input: do the rest of the program on them, then print out the top element of the stack and start again"
00:49:43 -!- ^_` has changed nick to GreaseMonkey.
00:49:45 <ehird> that adds a line number to all lines
00:49:57 <ehird> e.g. "a\nb\n\c\n" -> "1 a\n2 b\n3 c\n"
00:51:15 <ehird> quite elegant looking actually.
00:51:43 <ehird> that can be done simpler
01:07:13 -!- sekhmet has quit (calvino.freenode.net irc.freenode.net).
01:24:53 -!- olsner has quit ("Leaving").
01:45:10 <ehird> printf(x="printf(x=%c%s%c,34,x,34)",34,x,34)
01:48:20 <ehird> like the standard c quine, but with an inline assignment thingy
01:48:26 <ehird> pikhq: It's ruby. Do you still like it now? :D
01:49:03 <pikhq> I think that statement would also be valid C, actually.
01:49:11 <pikhq> God. A ruby-C polyglot.
01:49:22 * pikhq shudders some more at Ruby
01:49:26 <ehird> loads of polyglots support ruby.
01:49:33 <ehird> and it's valid c, if you have x defined
01:49:39 <ehird> main(x){printf(x="printf(x=%c%s%c,34,x,34)",34,x,34);}
01:49:50 <ehird> HA! HA! HA! HA! HA!
01:50:21 <pikhq> main(){printf(char*x="printf(char*x=%c%s%c,34,x,34",34,x,34);}
01:51:54 <pikhq> m(){p(c="p(x=%c%s%c,a,x,a)",a,x,a);} // if you allow judicious use of compile-time defines
01:52:20 <pikhq> m(){p(c="m(){p(x=%c%s%c,a,x,a);}",a,x,a);} // if you want it to also quine. :p
01:52:51 <oerjan> um, it's not a quine unless it includes the judicious defines
01:53:40 <pikhq> puts [join [split "puts \[a{a}]" a] {join [split "puts \[a{a}]" a] }]
01:53:54 <pikhq> A Tcl quine. My brain hurts.
01:55:19 <ehird> {'{C:.'}C}'{C:.'}C
01:55:37 <pikhq> format [set a {format [set a %s] $a}] $a
01:55:39 <ehird> {'{C:.'}C.}'{C:.'}C.
01:56:30 <ehird> pikhq: Figure that out.
01:56:56 * pikhq throws a calculus book at you
01:57:06 <ehird> 'char -> char ascii code
01:57:13 <ehird> {...} -> block, usable as string
01:57:17 <ehird> C -> print out char
01:57:21 <ehird> . -> print out thing
01:58:51 <ehird> pikhq: it's easy to figure out :P
02:00:59 -!- ehird has quit.
02:02:47 <pikhq> RodgerTheGreat: Either you're involved in Something Awful, or someone from there reads this channel.
02:03:07 * pikhq has stumbled upon a Something Awful thread discussing that scientology video. . .
02:03:15 <pikhq> And the "how to make a cult" video was also in there.
02:03:58 <pikhq> And the Steven Fishman deposition. . .
02:10:08 -!- Corun has joined.
02:34:26 -!- sekhmet has joined.
03:07:28 -!- Corun has quit ("Arr.").
03:11:54 -!- immibis has quit (Read error: 110 (Connection timed out)).
04:16:25 -!- calamari has joined.
04:45:31 <RodgerTheGreat> I'm not technically a goon, but I've been quite tempted to buy an account
04:51:28 <RodgerTheGreat> see if you can guess: http://nonlogic.org/dump/images/1201150121-aperTiles.gif
04:53:37 -!- oerjan has quit ("Good night").
05:06:27 -!- immibis has joined.
05:08:06 -!- adu has joined.
05:08:29 <adu> I started making my language
05:10:44 <adu> so far I've parsed the syntax into an AST, but now I don't know what to do
05:54:40 <pikhq> RodgerTheGreat: Fair 'nough.
05:55:38 <RodgerTheGreat> because as they say, "there's a hole in the sky, through which things can fly"
06:08:31 <calamari> but one is white so there's an empty space to move into :)
06:08:41 <RodgerTheGreat> they can be assembled into 2d maps for games like pokemon, zelda, mario and so on
06:09:16 <uvanta> you're working on 2-dimensional parody of Portal?
06:12:43 <RodgerTheGreat> I already have a 2d engine that can *very nearly* do what I need, so I just started pounding out some graphics
06:16:39 <RodgerTheGreat> graphical assets always feel like half the battle for game development, to me
06:30:28 <RodgerTheGreat> uvanta: what would you want to see in a 2d parody of portal?
06:30:48 <uvanta> that talking gun is necessary
06:37:11 <RodgerTheGreat> more stuff is completed: http://nonlogic.org/dump/images/1201156466-aperTiles.gif
06:40:40 <uvanta> RodgerTheGreat, you're surely aware of Portal Flash version, right?
06:46:06 <uvanta> I think the best thing of Portal as a game was suspensive/thrilling atmosphere
06:46:14 <uvanta> Puzzle genre is good for it
06:50:16 <uvanta> that tiles reminds me of Knytt Stories. http://nifflas.ni2.se/index.php?main=02Knytt_Stories
06:50:50 <uvanta> Knytt Stories is a nice puzzle/adventure game too
06:56:02 -!- schemacs has joined.
06:56:27 -!- schemacs has left (?).
07:17:48 -!- RodgerTheGreat has quit.
07:23:06 -!- uvanta_ has joined.
07:41:30 -!- uvanta has quit (Read error: 110 (Connection timed out)).
07:51:53 -!- helios24 has joined.
07:54:08 -!- puzzlet_ has quit (Remote closed the connection).
07:54:20 -!- puzzlet has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:01:57 -!- adu has quit (Remote closed the connection).
08:02:39 -!- puzzlet has quit (Remote closed the connection).
08:02:41 -!- puzzlet_ has joined.
08:03:00 <immibis> http://hadjin.sourceforge.net/wiki.php/IRC_log/2008/01/24/hadjin lol (ignore the bugged logger)
08:05:17 -!- calamari has quit ("Leaving").
08:05:41 -!- uvanta_ has changed nick to uvanta.
08:09:38 -!- puzzlet has joined.
08:10:12 -!- puzzlet_ has quit (Read error: 104 (Connection reset by peer)).
08:14:21 -!- puzzlet_ has joined.
08:14:25 -!- puzzlet has quit (Remote closed the connection).
08:16:35 -!- puzzlet_ has quit (Read error: 104 (Connection reset by peer)).
08:27:35 -!- puzzlet has joined.
08:28:24 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
08:38:18 -!- immibis has quit (Read error: 110 (Connection timed out)).
08:42:41 -!- puzzlet has joined.
08:43:12 -!- sarah87 has left (?).
08:54:16 -!- GreaseMonkey has quit (Client Quit).
09:21:11 -!- jix has joined.
09:23:20 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
09:23:24 -!- puzzlet has joined.
09:23:34 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
09:28:57 -!- puzzlet has joined.
09:33:21 -!- GregorR has quit (calvino.freenode.net irc.freenode.net).
09:33:21 -!- Asztal has quit (calvino.freenode.net irc.freenode.net).
09:33:23 -!- oklopol has quit (calvino.freenode.net irc.freenode.net).
09:33:23 -!- Overand has quit (calvino.freenode.net irc.freenode.net).
09:33:24 -!- AnMaster has quit (calvino.freenode.net irc.freenode.net).
09:33:24 -!- bsmntbombdood has quit (calvino.freenode.net irc.freenode.net).
09:34:08 -!- GregorR has joined.
09:34:08 -!- Asztal has joined.
09:34:08 -!- bsmntbombdood has joined.
09:34:08 -!- AnMaster has joined.
09:34:08 -!- Overand has joined.
09:34:17 -!- oklopol has joined.
09:36:02 -!- puzzlet has quit (Remote closed the connection).
09:36:10 -!- puzzlet has joined.
09:39:41 -!- Asztal has quit (Read error: 113 (No route to host)).
09:40:21 -!- Asztal has joined.
09:43:15 -!- puzzlet has quit (Remote closed the connection).
09:48:27 -!- puzzlet has joined.
09:49:00 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
09:53:24 -!- puzzlet has joined.
10:05:30 -!- puzzlet_ has joined.
10:09:39 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
10:17:37 -!- jix has left (?).
10:26:54 -!- Overand_ has joined.
10:38:25 -!- puzzlet_ has quit (Read error: 104 (Connection reset by peer)).
10:39:03 -!- puzzlet has joined.
10:42:14 -!- lifthrasiir has quit (calvino.freenode.net irc.freenode.net).
10:42:14 -!- lament has quit (calvino.freenode.net irc.freenode.net).
10:42:24 -!- Asztal has quit (calvino.freenode.net irc.freenode.net).
10:42:24 -!- sekhmet has quit (calvino.freenode.net irc.freenode.net).
10:43:27 -!- Asztal has joined.
10:43:27 -!- sekhmet has joined.
10:43:32 -!- Overand has quit (Read error: 110 (Connection timed out)).
10:43:33 -!- Overand_ has changed nick to Overand.
10:44:10 -!- lifthrasiir has joined.
10:44:10 -!- lament has joined.
10:52:20 -!- tejeez has quit (calvino.freenode.net irc.freenode.net).
10:56:58 -!- cmeme has quit (Connection timed out).
11:04:57 -!- cmeme has joined.
11:04:59 -!- tejeez has joined.
11:15:07 -!- Tritonio_ has joined.
11:44:11 -!- helios24 has quit ("Leaving").
13:24:02 -!- MommeMC has joined.
13:35:48 -!- ehird has joined.
13:44:05 -!- jix has joined.
13:47:31 <ehird> {'{C:.'}C.}'{C:.'}C. ; is this a cheat quine?
13:47:43 <ehird> it relies on something akin to javascript's ability to print out a funcs source
13:57:57 -!- RodgerTheGreat has joined.
14:05:36 -!- timotiis has joined.
14:38:14 -!- uvanta has quit ("blame!").
14:40:30 -!- salparot has joined.
14:41:10 -!- salparot has changed nick to olsnerWk.
14:54:32 -!- Tritonio__ has joined.
14:55:44 -!- Tritonio_ has quit (Read error: 110 (Connection timed out)).
14:59:07 -!- puzzlet has quit (Remote closed the connection).
14:59:14 -!- puzzlet has joined.
15:04:31 <Asztal> hmm... bef pushes the value of an uninitialised stack variable if & fails
15:05:14 -!- oerjan has joined.
15:07:46 <Asztal> the reference befunge-93 interpreter, and the one anarchy golf uses
15:22:01 -!- MommeMC has quit.
15:23:24 -!- olsnerWk has quit ("Changing server").
15:41:25 -!- MommeMC has joined.
15:41:28 -!- MommeMC has quit (Client Quit).
15:53:57 -!- calamari has joined.
15:54:32 -!- sebbu has joined.
16:02:14 -!- calamari has quit ("Leaving").
16:17:47 -!- puzzlet has quit (Remote closed the connection).
16:17:52 -!- puzzlet has joined.
16:23:40 -!- ehird has quit (Read error: 104 (Connection reset by peer)).
16:29:05 -!- jix has quit ("CommandQ").
16:35:55 -!- jix has joined.
16:39:19 -!- jix has quit (Nick collision from services.).
16:39:27 -!- jix has joined.
16:55:09 -!- Slereah has quit ("Konversation terminated!").
17:02:32 -!- slereah_ has joined.
17:48:10 -!- ais523 has joined.
17:53:15 -!- ais523 has quit ("restarting my window manager").
17:59:00 -!- ais523 has joined.
18:20:11 -!- Corun has joined.
18:21:03 -!- RedDak has joined.
18:35:30 -!- oerjan has quit ("leaving").
19:56:53 -!- helios24 has joined.
20:05:13 -!- SimonRC_ has joined.
20:05:13 -!- SimonRC has quit (Read error: 104 (Connection reset by peer)).
20:07:50 -!- faxathisia has joined.
20:25:24 <ais523> it's unusually quite here
20:28:44 <tejeez> i should go to sleep soon
20:43:17 <ais523> it's probably quite because it isn't the case that ehird and me are here simultaneously
20:43:33 <ais523> that's what caused all the traffic over the previous few days
20:44:03 <slereah_> Let's make up some awesome project that we'll never do but will talk about to no end.
20:44:46 * faxathisia wants to write programs to solve combinatory logic problems..
20:45:29 <ais523> what sort of problems?
20:45:34 <slereah_> That mockingbird is laughing at you!
20:45:39 <ais523> unabstraction already exists and can be done automatically
20:45:42 <slereah_> I assume the riddles in "To mock a mockingbird"
20:46:00 <faxathisia> say you have a set of combinators, Try to produce some new combinator from them
20:46:07 <slereah_> Stuff like "prove that with the existance of the mockingbird, there's birds that love such bird" and stuff.
20:46:26 <ais523> I don't think you can do that much with just a mockingbird
20:46:30 <slereah_> (The vocabulary in to mock a mockingbird isn't very standard)
20:46:34 <ais523> because applying it to itself gives an infinite loop
20:46:40 <faxathisia> I cant use typing because it's all in untyped lambda calc
20:46:44 <ais523> and if it's the only combinator, you can't do anything else with it...
20:47:02 <slereah_> But the first chapter says that it exists.
20:47:10 <slereah_> And some other axioms that I forgot
20:47:22 <slereah_> With that, you can prove some properties for all combinators
20:48:18 <faxathisia> Like, every combinator has a fixed point\
20:48:44 <slereah_> It was "Fond of" in the book IIRC
20:49:15 <ais523> and from that, you can prove that some things that sound like combinators can't be
20:49:15 <faxathisia> Any ideas for an algorithm for this? :S
20:49:34 <ais523> such as detecting if a function is a particular combinator or not
20:50:03 <slereah_> If I knew one, I would have found the solution on my own!
20:50:36 <ais523> you could just brute-force, I suppose
20:50:51 <ais523> but even determining whether two combinators are the same is sometimes difficult
20:50:56 <ais523> and I suspect it's undecidable in general
20:51:12 <faxathisia> ais523, Yeah I tried this, the problem is that It's undecidable if untyped lambda terms are equal
20:51:35 -!- ehird has joined.
20:51:46 <ais523> I find that up to a point, Haskell is quite good for identifying combinators, but past that point it's useless
20:51:57 <ais523> because you can't fit a mockingbird into the normal type system...
20:52:07 <ehird> ais523: you kind of can
20:52:27 <ehird> Maybe you meant the pure Y combinator
20:52:36 <ais523> Prelude> let m x = x x
20:52:37 <ehird> faxathisia: we need a typesystem allowing construction of the infinite type
20:52:43 <ais523> Occurs check: cannot construct the infinite type: t = t -> t1
20:52:50 <ehird> ais523: works for me
20:52:51 <slereah_> faxathisia: Have you looked at the solution?
20:53:13 <ais523> ehird: I'm using ghci, and it definitely doesn't let me define m x to be x x
20:53:14 <faxathisia> slereah, No, I'm going to work it out.. It's just taking weeks :P
20:53:22 <ais523> because it's type would be t -> t -> t -> t -> t -> ...
20:53:44 <ais523> on the other hand, combinators like s and k are easily identified from their types
20:53:48 <slereah_> I'll read it again, and tell you if it gives me an awesome algorithm idea
20:53:50 <ehird> faxathisia: that's not Y
20:54:01 <ehird> Y is the lambda calculus form
20:54:05 <ehird> and contains no free names
20:54:37 <faxathisia> It's equal to the y-combinator then...
20:55:01 <ehird> faxathisia: just like every other fixed point combinator
20:55:02 <ehird> doesn't mean it's Y
20:55:24 <ais523> according to Wikipedia, Y is the best known fixed point combinator
20:55:37 <ais523> and y f = f (y f) is one way to describe its behaviour
20:55:42 <slereah_> Is it the "every bird is fond of at least one bird"?
20:56:09 <faxathisia> ok, please don't tell me the answer if you do get it, but given Qxyz = y(xz) and Txy = yx, Can you make Bxyz = x(yz) ?
20:56:51 <slereah_> (Working on lazy bird got me the names in mah noggin)
20:56:55 <faxathisia> I wrote a typechecker for STLC, and it can type y
20:57:57 <ehird> faxathisia: lazy version?
20:58:05 <faxathisia> It's useless for solving these problems though, http://rafb.net/p/uFekWO50.txt
20:58:14 <ais523> Wikipedia defines Y as S (K (S I I)) (S (S (K S) K) (K (S I I))) in ski form, so that should be enough to be an unambiguous definition
20:58:18 <ais523> assuming it's right, of course
20:58:24 <slereah_> faxathisia: Is it question 37?
20:58:43 <faxathisia> ehird, not sure what you mean, It's using herbrands unification algorithm
21:00:14 <slereah_> Seeing the answer, brute force might work.
21:00:23 <ehird> faxathisia: the lazy Y
21:00:34 <ehird> \f. (\x. f (x x)) (\x. f (x x))
21:00:35 <slereah_> But it doesn't really offer a detailed demonstration
21:00:52 <ehird> \f. (\x. f (\y. (x x) y)) (\x. f (\y. (x x) y))
21:00:53 <slereah_> Just proves that the answer produce the same result
21:00:58 <ehird> that is useless in any strict lanug
21:01:08 <faxathisia> ((lambda (m) ((lambda (x) (x x)) (lambda (y) (m [lambda (n) ((y y) n)])))) <-- the lambda in []'s is like basically a trick
21:01:48 <faxathisia> ((lambda (m) ((lambda (x) (x x)) (lambda (y) (m (y y)))))) ;; Should work in a lazy lisp
21:01:59 <ehird> faxathisia: not standard
21:01:59 <ehird> here is a simple, self-referencing fixpoint
21:02:08 <ehird> (define (fix f) (f (lambda (x) ((fix f) x)))
21:02:15 <ehird> faxathisia: the [..]
21:02:33 <ehird> check r5rs if you don't believe me (r6rs is shit)
21:02:37 <faxathisia> I am using [] to show exactly which lambda I am referring to
21:03:03 <faxathisia> It saves me using two lines, one with ^^^^^
21:03:42 <faxathisia> anyway the cool thing is that you can create recursion
21:04:07 <ehird> thats the point of the fixedcombinator
21:08:09 -!- slereah__ has joined.
21:08:47 <slereah__> faxathisia: You might want to check how the arguments of combinators affect the arity of the resulting combinator.
21:09:00 <slereah__> Might shorten the search, since you know B only has 3.
21:11:13 <slereah__> For instance, Q(something)Q adds two to the arity, T only one.
21:11:40 <slereah__> (I tried to do that kind of conversions when trying to shorten some lazy bird programs)
21:12:34 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
21:12:51 <slereah__> Although it was useful to notice when it was useless to try to reduce some combinator
21:12:55 -!- slereah__ has changed nick to Slereah.
21:16:42 <faxathisia> I first worte a program that generates every combination of a set of combinators, then checks if they are equal
21:17:23 <Slereah> How does it check for equality?
21:17:25 <faxathisia> I checked equality as you would with STLC, so it can only solve the really basic problems
21:17:51 <faxathisia> just see if the simple types of the lambda terms unify
21:18:00 <Slereah> I don't speak that moonspeak.
21:18:25 <Slereah> But well, since it's just B, you can probably just apply three dummy combinator to it.
21:18:31 <Slereah> That's how I do it for most.
21:19:20 <faxathisia> you can check that unifying the type of SKK works
21:20:17 <faxathisia> and since it does they must be equal, but yeah.. This is not working in general since lots of valid term in combinatory logic don't type
21:21:14 <faxathisia> so I think I'll try to solve the problem from the other end..
21:21:18 <ais523> "Few languages ever become sufficiently popular that they are used by more than a few people" -- quote I just came across on Wikipedia
21:21:21 <Slereah> Problems usually arise when there's lambdas in the lambda expression
21:21:33 <faxathisia> start mangling the solution until I get a solution
21:25:14 <Slereah> I'll give you brute force, you'll see!
21:27:44 <Slereah> http://membres.lycos.fr/bewulf/Russell/Lazy%20Bird/Lazy%20Bird%204.py
21:27:50 <Slereah> Although this one lacks q.
21:28:32 <Slereah> http://membres.lycos.fr/bewulf/Russell/Lazy%20Bird%205.py
21:29:05 <Slereah> Same syntax as Unlambda. Use a, n, p or x as dummy variables.
21:29:15 <Slereah> The evolution of the expression is displayed.
21:33:02 <Slereah> The program halts if the previous expression is the same as the current one
21:33:24 <Slereah> But ```sii``sii won't stop
21:34:51 <ais523> ```sii``sii optimises into Underload's (:^):^, which doesn't accumulate is anywhere
21:35:27 <Slereah> Well, with lazy evaluation, it forgets that part.
21:35:33 <faxathisia> ``s``s`ks``s`k`s`ks``s`k`s`kkk`k``s``s`ksk`ki
21:36:05 <Slereah> It is rather a pain to do it by hand!
21:36:26 <ais523> ```sii``sii -> ``i``sii`i``sii -> ```sii`i``sii -> ```sii``sii with eager evaluation
21:36:27 <Slereah> You can check with sum dummy combinators, too!
21:36:33 <ais523> and Underload and Unlambda are eager
21:36:41 <ais523> so there's no accumulation of is
21:38:39 <Slereah> faxathisia: Use the ABSTRACTOR for that though
21:39:18 <Slereah> I've got some "Feather trimming" program in project somewhere, to try to do some minimal length formula
21:39:19 <faxathisia> Is there a description of this ``` syntax?
21:39:28 <Slereah> Well, it's polish notation
21:39:56 <Slereah> There's a simple trick : take an expression with parenthesis
21:49:33 -!- sebbu2 has joined.
21:52:22 <Slereah> http://membres.lycos.fr/bewulf/Russell/BRUTE%20FORCE.txt
21:52:28 <Slereah> The solution is at the end.
21:52:41 <Slereah> All you had to do was to waste half an hour!
21:54:03 <Slereah> I did it in quite a stupid fashion, since I used expressions without t or q
21:54:26 <Slereah> And I probably should have checked what kind of formulas would end up on something with three variables
21:54:37 -!- sebbu has quit (No route to host).
21:54:37 -!- sebbu2 has changed nick to sebbu.
21:55:17 <faxathisia> ``s``s`ks``s`k`s`ks``s`k`s`kkk`k``s``s`ksk`ki = ((s ((s (k s)) (k s))) ((s (k s)) (k s)))
21:56:09 <Slereah> ((S((S(KS))(KS)))((S(KS))(KS)))
21:56:22 <Slereah> Well, that's after reduction.
21:57:16 <Slereah> I did it the other way around.
21:57:44 <Slereah> Lazy Bird does everything in combinators in polish notation, so it translates the input into that
21:57:50 <faxathisia> this seems to sort of work then, http://rafb.net/p/mMCqUh43.txt
21:58:15 <Slereah> I really can't read Haskell.
21:58:49 -!- helios24 has quit ("Leaving").
21:58:57 <ehird> Slereah: its easy once you laern it
21:59:04 <Slereah> I just did (string.replace(")","")).replace("(","`")
21:59:19 <ehird> q[]=[];q(x:xs)=q(filter(< x)xs)++q(filter(>= x)xs)
21:59:21 <Slereah> That's how bad I know Haskell, faxathisia
21:59:37 <faxathisia> I'm going the other way, It's (bad) scheme btw
21:59:45 <ehird> Slereah: that's lisp
21:59:53 <Slereah> Well, I didn't really do that, because there's the case where there's a .( or .)
21:59:57 <ehird> hint: look for parentheses
21:59:59 <Slereah> But it's the basic concept
22:00:24 <Slereah> Isn't Haskell a baby of Lisp?
22:00:41 <faxathisia> That should be enough to tell them apart
22:01:52 <faxathisia> Lisps and Haskell are based on different lambda calcs
22:02:26 <faxathisia> MLs are generally typed, polymorphic with some other stuff
22:03:06 <faxathisia> (they can have types.. but it's still based on untyped)
22:08:34 -!- RedDak has quit ("I'm quitting... Bye all").
22:13:17 -!- danopia has joined.
22:18:42 -!- ais523 has quit ("bye").
22:19:46 <ehird> <ais523> anyway, I'm being thrown out from my Internet connection again
22:19:46 <ehird> [22:18] <ais523> this always happens about 10:20pm, by the way
22:20:11 <Slereah> EgoBot can timetravel ehird.
22:20:26 <Slereah> He was built that way, because he runs on TwoDucks.
22:20:46 -!- jix has quit ("CommandQ").
22:22:01 -!- GregorR has quit ("Leaving").
22:23:19 -!- oerjan has joined.
22:29:00 <Asztal> speaking of which, vistaids has decided I can't open any more TCP connections. Rebooting :(
22:30:23 -!- Asztal has quit (Read error: 104 (Connection reset by peer)).
22:32:57 -!- Asztal has joined.
22:34:30 <Slereah> Hm. Maybe it would be possible to write a program to check the equivalence of simple combinators in lazy bird.
22:35:10 <Slereah> You take two combinators. Apply the adequate number of dummy variable, let them convert, compare them with the delta operator
22:35:51 <Slereah> Maybe some code to generate all possible combinators from q and t also, in the case at hand
22:36:29 <Slereah> It would only work for combinators that works for all type of variables, but that's good enough for B and the like
22:37:56 -!- sebbu has quit (Read error: 60 (Operation timed out)).
22:41:00 -!- EgoBot has quit (Read error: 110 (Connection timed out)).
22:52:04 <Slereah> Half-adder on finger binary is okay But full adders are some moar srs business!
23:03:00 -!- sebbu has joined.
23:10:32 -!- timotiis has quit ("leaving").
23:11:21 <faxathisia> I think an algorithm like this could work
23:12:08 <faxathisia> It is non-deterministic, So in this case (I have no idea for a heuristic) it might make sense to breadth first search
23:18:09 <faxathisia> say I wanted to make Idiot, out of Warbler & Lark
23:18:43 <Slereah> Idiot is such a mean name.
23:18:50 <faxathisia> I can start with the lambda term (λ x x), and unapply Warbler or Lark
23:18:52 <oerjan> that _does_ sound pretty idiotic already, funny words those...
23:18:55 <Slereah> You know well that he loves every bird!
23:19:26 <Slereah> How's the unapplying done?
23:23:18 <faxathisia> I can suppose, (λ x x) = ((λ x (λ y ((x . y) . y))) . ?1)
23:23:46 <faxathisia> so all I have to do then (after alpha-beta) is solve ((?1 . x) . x) = x
23:24:46 <faxathisia> so I get the solution (λ x x) = ((λ x (λ y ((x . y) . y))) . (λ x (λ y x))) = (W . K)
23:27:26 -!- RockerMONO has joined.
23:28:19 <Slereah> ``^x^y`````tky.xr``xx``v``t0y```t`sb``tky``t0y^x^y`````tky.xr``xx``v``t0y```t`sb``tky``t0y``v0i
23:28:44 <RockerMONO> anyone know the most verbose code for outputting 'verbose' in brainfuck? :D
23:28:58 * RockerMONO is just getting into brainfuck and feels like messing around ab it
23:29:03 <Slereah> Here's a shorter oen : ``m^x^y`````tky.xr``xx``v``t0y```t`sb``tky``t0y``v0i
23:29:17 <Slereah> RockerMONO: Define "Most verbose".
23:29:27 <Slereah> You could theorically use an infinite number of symbols!
23:29:35 <RockerMONO> Slereah: as in exteremely overly lengthy useless code =P
23:29:44 <Slereah> Like an absurd quantity of <> that would do nothing
23:30:06 <RockerMONO> i was thinking maybe going to 0 before doing each character? :)
23:30:30 <oerjan> using only + > and . would be pretty verbose
23:30:36 <Slereah> Well, that's how you would do it if you printed it on every cell!
23:30:50 <Slereah> Like ++++....+++ > ++++.... +++ > +++....
23:31:10 <Slereah> And then, go back to 0, and print, >, print, until you're on 000 again
23:31:19 * oerjan assumes .... means ellipsis
23:31:28 <ehird> Slereah: constant folding pwns your pitiful attempts
23:31:40 <ehird> actually, a good brainfuck compiler should generate programs like printf("hello world\n"); when it can
23:32:27 <Slereah> I can't think of a verboser way that wouldn't be just adding completely useless characters
23:33:00 <Slereah> Well, maybe you could write it in some code on the tape, and use another part of the program to decode it and print it!
23:33:22 <Slereah> Like you write it in binary, except it's actually a bunch of "0" and "1" char
23:34:13 <oerjan> do it as a COBOL program + interpreter. that _surely_ would be verbose.
23:34:51 -!- olsner has joined.
23:35:21 <olsner> so, I'm working on a sed script that translates thue into mod_rewrite rules... testing it on a brainfuck interpreter written in thue :P
23:35:42 <ehird> olsner: do you get a crapload of redirects or something?
23:35:47 <ehird> as if you stepped through it in your url bar
23:35:57 <RockerMONO> http://nonlogic.org/dump/text/1201217590.html <-- guess what that does :D
23:36:24 * RockerMONO should strip the newline characters...
23:36:50 <olsner> basically you write http://host/brainfuckProgram:000_001_010_ to execute the brainfuck program on input [0,1,2]
23:37:45 <Slereah> Idea : Write a program that will input a brainfuck interpreter in brainfuck, which will do the same, and so on.
23:37:59 <olsner> and I rewrite it to print.php?output in the end, and let print.php just print that string
23:38:56 <olsner> have a few bugs in it I think... and the sed script isn't exactly readable (regexps producing regexps ^^)
23:41:21 <Slereah> I think that's the shortest Fibo in Lazy Bird : ``m^x^y````yk.xr``xx``v`y0```t`sb`yk`y0``v0i
23:42:24 <Slereah> ``m^x^y````yk.xr``xx``v`y0```yk`sb`y0``v0i
23:42:35 <olsner> oh noes, mod_rewritwe translates ? into a request with a query string... and only uses the URI part for future matching... more ugly sed hacking :S
23:42:47 <Slereah> It is painfully slow, but it does output Fibonacci!
23:43:33 <RockerMONO> http://nonlogic.org/dump/text/1201218034.html = pure evil :)
23:43:47 <ehird> olsner: you can tell it to match whole
23:45:55 <olsner> hmm... the apache manual suggests otherwise: "The Pattern will not be matched against the query string."
23:46:28 <olsner> http://httpd.apache.org/docs/2.0/mod/mod_rewrite.html#rewriterule under "Note: Query String"
23:49:22 <Slereah> And here it is, in combinators : ``m``s`k`s``s``s`o`kk`k.1`kr``s``s`ks``s``s`kskk`k``s``s`kv`o`k0``s``s`o`kk`k`sb`o`k0``v0i
23:49:55 -!- uvanta has joined.
23:50:27 <olsner> seems the workaround they recommend is to match URI and query string separately, with a RewriteCond %{QUERY_STRING} ... before the RewriteRule
23:51:57 <RockerMONO> http://nonlogic.org/dump/text/1201217590.html <-- Microsoft EULA translated into brainfuck *insert evil grin here*
23:52:41 <ehird> makes about as much sense
23:54:18 <RockerMONO> looking at that page in firefox may be worse than waiting for it to compile >.>