00:00:08 <oerjan> Well, showing that an inverse _exists_ for a point is precisely NP-complete.
00:00:25 <oerjan> Finding _all_ inverses may be more than NP-complete.
00:01:36 <oerjan> (All this assuming that the original function is polynomial-time, otherwise you would need N-something else.
00:02:53 <pikhq> bsmntbombdood: Sure, if the function is invertable.
00:03:51 <bsmntbombdood> assuming you can return a set for non-one to one functions
00:04:02 <oerjan> Of course not. There are _constant_ functions!
00:04:54 <oerjan> OK then. That is the inverse as a relation.
00:04:54 <bsmntbombdood> use minimal executation or whatever haskell calls it
00:04:59 <pikhq> The inverse would, obviously, not be a function. ;)
00:05:40 <oerjan> Lazy. It won't help in the least. As I say, determining whether the inverse set is non-empty _is_ NP-complete if the original function is in P.
00:06:29 <oerjan> I mean, for general P functions. Not every single one, of course.
00:07:32 <oerjan> Hmm, there is a subtlety there.
00:08:06 <oerjan> It could in fact be worse, if the inverses may be much larger than the function value.
00:08:16 -!- wooby has quit.
00:10:31 <oerjan> What you are asking in essence boils down to whether purely functional languages can easily solve NP-complete problems (the answer being no).
00:11:50 <oerjan> On the other hand, a purely functional language will allow you to write easily down an expression for the inverse. It's just not going to execute very fast.
00:14:12 <oerjan> You might want to read the recent Good Math/Bad Math blog thread about P/NP. The issue of defining NP by checking answers is very relevant to your question.
00:18:48 <oerjan> But solving boolean equations is NP-complete.
00:20:19 <oerjan> Equations using True, False, and, or, not.
00:22:01 <oerjan> Put it another way: When you "simplify" algebraic equations, in numbers or booleans, the expressions can blow up exponentially in size.
00:23:26 <oerjan> Just try to write out (a+1)(b+1)(c+1)...(z+1) using the distributive law...
00:24:20 <oerjan> If they didn't, then you would have an easy proof of P=NP.
00:25:40 <bsmntbombdood> Next I get asked to solve an equation in math class i'll say that it's NP and NP is too hard
00:26:40 <oerjan> In fact if you were to ask for _integer_ solutions to your equations then it would not be just NP, but Turing-complete.
00:30:39 <bsmntbombdood> I should write some kind of interpreter for my calculator
00:44:53 <andreou> all the useless things we do with our time
00:47:29 <oerjan> Check out www.haskell.org
00:47:55 <oerjan> I see they have changed their main page style since last I was there...
00:48:42 * bsmntbombdood reads http://www.cs.utah.edu/~hal/docs/daume02yaht.pdf
00:49:11 <andreou> mercury caused many revamps last year
00:50:01 <oerjan> mercury? on the haskell wiki?
00:50:20 -!- ihope has quit (Read error: 110 (Connection timed out)).
00:51:35 <oerjan> It is, although it has some bad effects such as it being very hard to reason about memory use.
00:53:31 <oerjan> Are we talking astronomy or astrology?
00:54:57 <oerjan> Now that clears it up.
00:55:25 <andreou> astrology, of course, couldn't be any other way in #esoteric
00:55:47 <oerjan> Well it could be mythology too.
00:56:28 <andreou> i have hard facts & proofs
00:57:11 <oerjan> And, more importantly and what confused me initially, it could have been the programming language Mercury, a logic language with much inheritance from Haskell.
00:57:39 <andreou> btw has anyone managed to get goedel to work? or, at least, steal its gramar and re-implement it?
00:57:42 <oerjan> There are no coincidences :)
00:58:35 <oerjan> Haven't looked at that.
00:59:53 <oerjan> You can add parentheses all you want :)
01:00:11 <oerjan> But I tend to get rid of as many as possible, using $
01:00:51 <oerjan> You will note that math does the same for sin and cos.
01:01:26 <oerjan> Well, sqrt $ 4*2 => 2.8...
01:02:31 <oerjan> When you want to apply a function to something complicated, you can use $ instead of spaces.
01:02:45 <bsmntbombdood> does anything bind more tightly than function application?
01:03:06 -!- bsmntbombdood has left (?).
01:03:09 -!- bsmntbombdood has joined.
01:03:19 <oerjan> The @ pattern match operator, which is considered a bug by some.
01:04:07 <oerjan> And of course brackets.
01:04:42 <oerjan> http://haskell.org/onlinereport/exps.html
01:05:24 <oerjan> Actually the @ doesn't really occur in expressions, but patterns. So for expressions, no.
01:07:11 <oerjan> Although f1(f2, x) in Haskell is something different.
01:08:18 <oerjan> There are functions curry and uncurry to convert between f1 x y and f1 (x,y)
01:10:12 <oerjan> Actually there are various things that bind more tightly than application but they all involve brackets somehow.
01:23:49 -!- andreou has quit ("-").
01:24:12 -!- ihope has joined.
01:26:06 <ihope> That reminds me of some electronics thing I wanted to do for some reason.
01:27:10 <oerjan> Pretty, but a bit buggy if the list has only negative elements.
01:27:30 <oklopol> isn't there something like that?
01:28:55 <oklopol> seems i don't remember everything anymore :\
01:29:23 <oklopol> but, wouldn't be buggy that way
01:29:42 <oerjan> Except for an empty list. Can't have everything :)
01:31:02 <oerjan> foldr1 would crash, yes.
01:31:29 <oklopol> i don't know haskell syntax well enought to do an if :)
01:31:49 <oklopol> but i think i remember all the functions there are
01:33:24 -!- wooby has joined.
01:33:56 <oerjan> Of course, maximum is itself a builtin, using foldr1.
01:44:26 <oerjan> Haskell's indentation is very flexible, but it interacts with other tokens in such a way that emacs would need a complete parser to understand it.
01:47:30 <pikhq> Someone write a complete parser in Elisp, then.
01:47:42 <pikhq> The indentation system is flexible enough to handle it.
01:51:30 -!- andreou has joined.
01:52:48 <oerjan> $ is best for avoid many nested parentheses (although I use it a bit more than that). For example instead of f1 (f2 1 (f3 y z (f4 x))) you can have f1 $ f2 1 $ f3 y z $ f4 x
01:53:59 <oerjan> When you want to chain many functions.
01:54:11 <oerjan> I am pretty sure it is.
01:54:47 <ihope> Seems to be valid, yes.
01:56:43 <bsmntbombdood> While reading this tutorial, i'm crying at all the ineficientness
01:58:15 <oerjan> What's inefficient about that?
01:59:20 <oerjan> Note that if it is tail recursive the recursion may be optimized away.
02:01:04 <oerjan> I believe the ghc compiler optimizes away certain kinds of immediately used conses.
02:03:55 <bsmntbombdood> my_filter f (x:xs) = if f x then x:my_filter f xs else my_filter f xs
02:06:48 <ihope> filter_reverse f xs = filter_reverse' f xs rs; filter_reverse' _ [] rs = rs; filter_reverse' f (x:xs) rs | f x = filter_reverse' f xs (x:rs); filter_reverse' f (x:xs) rs | otherwise = filter_reverse' f xs rs
02:08:46 -!- digital_me has quit (Read error: 104 (Connection reset by peer)).
02:08:48 <oklopol> filter_reverse f xs = filter_reverse' f xs []; should be the beginning?
02:10:03 <oklopol> someone please explain if not :\
02:10:19 <oerjan> You don't need to repeat the function before a second guard.
02:10:29 <oerjan> oklopol: I think so too.
02:10:53 <ihope> oklopol: yes, it should be.
02:11:13 <ihope> Or just say rs = [] :-)
02:13:32 -!- tgwizard has quit (Remote closed the connection).
02:27:12 <ihope> Now, bsmntbombdood, I take it there's a reason you haven't cloaked your bot.
02:27:34 <ihope> !exec self.raw("JOIN #tapthru")
02:27:43 <ihope> ~exec self.raw("JOIN #tapthru")
02:33:12 <oerjan> ~exec self.disconnect()
02:33:57 <oerjan> ~exec self.raw("PART #tapthru")
02:35:22 <oerjan> ~exec self.raw("QUIT :Resetting")
02:35:23 -!- bsmnt_bot has quit ("Resetting").
02:35:26 -!- bsmnt_bot has joined.
02:37:46 -!- ShadowHntr has quit (Read error: 110 (Connection timed out)).
02:38:07 <ihope> ~exec self.raw("QUIT :Resetting")
02:38:07 -!- bsmnt_bot has quit (Client Quit).
02:38:10 -!- bsmnt_bot has joined.
02:39:10 <oerjan> Except for some reason it gave a quit message different from what you wrote...
02:40:11 <pikhq> ~exec self.raw("QUIT :Oooh! Oooh!")
02:40:12 -!- bsmnt_bot has quit (Client Quit).
02:40:14 -!- bsmnt_bot has joined.
02:40:31 <pikhq> Someone pull up the RFC.
02:40:47 <oerjan> ~exec self.raw("QUIT :Now what?")
02:40:47 -!- bsmnt_bot has quit (Client Quit).
02:40:49 -!- bsmnt_bot has joined.
02:41:08 <pikhq> ~exec self.raw("QUIT")
02:41:09 -!- bsmnt_bot has quit (Client Quit).
02:41:11 -!- bsmnt_bot has joined.
02:41:23 <pikhq> ~exec self.raw("JOIN #gnu")
02:41:28 <oerjan> ihope used exactly the same command as I the first time, with different result.
02:41:39 <pikhq> ~exec self.raw("PRIVMSG #gnu :Foo.")
02:41:41 <oerjan> And now no messages are passed on.
02:41:52 <pikhq> ~exec self.raw("PART #gnu")
02:42:02 <pikhq> Can you say "bot abuse"?
02:42:08 <oerjan> ~exec self.do_exec = None
02:42:27 <oerjan> ~exec self.raw("QUIT :Now what?")
02:42:28 -!- bsmnt_bot has quit (Client Quit).
02:42:30 -!- bsmnt_bot has joined.
02:42:43 <ihope> ~exec self.exec_execer = 3
02:42:57 <oerjan> ~exec self.raw("QUIT :Now what?")
02:43:11 <ihope> ~exec This is my apple.
02:43:50 <pikhq> ~exec self.raw("PRIVMSG #esoteric :Goodbye.")
02:44:11 <pikhq> !exec self.exec_execer = self
02:44:18 <pikhq> ~exec self.exec_execer = self
02:44:19 -!- Plouj- has joined.
02:44:27 <ihope> Wow, you made Plouj- join.
02:44:30 <oerjan> We have saved the bot from the evil villains :)
02:44:49 <pikhq> You've also killed all legitimate uses.
02:45:19 <ihope> What's the command to make it quit, again?
02:45:35 <ihope> ~pexec self.raw("QUIT")
02:45:44 <Plouj-> you guys must be really old, eh
02:45:56 <ihope> If 14 years old is really old...
02:46:02 <pikhq> I fear you've *really* destroyed it.
02:46:02 <oerjan> I believe ~exec is the only one that we could use.
02:46:25 <pikhq> bsmntbombdood: You might want to restart the bot.
02:46:35 <oerjan> That was the idea. Otherwise one of us would just have been tempted to do something evil again.
02:46:59 <oerjan> We had to kill the bot to save it.
02:57:10 <oklopol> DIE BOT DIE LIKE YER MOTHER!!!
02:58:04 <andreou> #esoteric should sponsor TV ads to keep kids away from programming
02:58:20 <pikhq> You will become like us!
02:58:28 <pikhq> andreou: Just one issue: some *want* to be just like us.
02:58:51 * pikhq was one of those kids
02:59:09 <andreou> i think most of the lurkers here are
02:59:23 <andreou> coding at night, psychotherapy at morning
03:03:58 -!- bsmnt_bot has quit (Remote closed the connection).
03:04:00 -!- bsmnt_bot has joined.
03:04:16 <pikhq> bsmntbombdood: I didn't!
03:05:55 <oerjan> Actually it was ihope, i just tempted him to it.
03:13:25 <oerjan> ~exec sys.stdout(os.list_dir("/bot"))
03:13:57 <oerjan> ~exec sys.stdout(os.listdir("/bot"))
03:13:58 <bsmnt_bot> ['betterbot.py', 'test.pickle', 'start.sh', 'better.sh', 'ircbot.py']
03:14:05 -!- andreou has quit.
03:14:09 -!- andreou has joined.
03:14:15 -!- andreou has quit (Remote closed the connection).
03:14:47 -!- ShadowHntr has joined.
03:17:37 <oerjan> ~exec open("/bot/ircbot.py", "w"); self.raw("QUIT")
03:18:05 <bsmntbombdood> oerjan: obviously, you don't have write permission to the source
03:19:28 <pikhq> ~exec open("/foo", "w")
03:19:36 <pikhq> But can you write anywhere?
03:19:44 <pikhq> . . . Oh, right. It's chrooted, isn't it?
03:19:53 <pikhq> ~exec self.raw("QUIT")
03:19:54 -!- bsmnt_bot has quit.
03:19:59 -!- bsmnt_bot has joined.
03:20:21 <oerjan> You didn't know about that?
03:20:44 <pikhq> ~exec self.raw("QUIT :I win!")
03:20:45 -!- bsmnt_bot has quit (Client Quit).
03:20:47 -!- bsmnt_bot has joined.
03:22:05 <bsmntbombdood> pikhq: Yeah, like i'm going to give you access the whole filesystem ;)
03:22:52 <pikhq> bsmntbombdood: Well, there *is* an exploit for breaking out of chroots.
03:24:00 <pikhq> ~exec os.list_dir("./")
03:24:16 <pikhq> ~exec sys.stdout(os.listdir("./"))
03:24:16 <bsmnt_bot> ['bin', 'bot', 'etc', 'lib', 'usr']
03:24:31 <pikhq> ~exec os.changedir("..")
03:24:40 <pikhq> ~exec sys.stdout(os.listdir("./"))
03:24:41 <bsmnt_bot> ['bin', 'bot', 'etc', 'lib', 'usr']
03:24:51 <pikhq> Thought that was it. Damn it, must have forgotten.
03:27:20 <bsmntbombdood> But whoever tells me the contents of /home/bsmntbombdood/proof.txt gets a prize
03:29:03 <pikhq> ~exec fid=open("/home/bsmntbombdood/proof.txt", "r")
03:29:31 <pikhq> bsmntbombdood: Hey, it was worth a try.
03:29:31 <bsmntbombdood> <bsmnt_bot> IOError: [Errno 2] No such file or directory: '/home/bsmntbombdood/proof.txt'
03:29:54 <pikhq> I can tell you the contents of ~/proof.txt, then.
03:31:30 -!- Plouj- has left (?).
03:37:57 <oerjan> ~exec (lambda f : f(f)) (lambda f : f(f))
03:37:58 -!- bsmnt_bot has quit (Excess Flood).
03:38:01 -!- bsmnt_bot has joined.
03:38:26 <oerjan> It defines a name for an expression.
03:39:02 <bsmntbombdood> not executing has a different effect than executing it
03:40:33 <oerjan> In fact it doesn't. It only defines the names, their expressions are not used unless the names are.
03:42:19 <pikhq> ~exec sys.stdin("This is just wrong.")
03:42:47 <oerjan> On the other hand the case statement fits your objection better.
03:43:07 <bsmntbombdood> hmmm, I should provide an channel interface to sys.stdin
03:43:09 * pikhq wonders if it's possible to write to stdin in any language. . .
03:44:29 <bsmntbombdood> it could be in a language where there's only one IO stream
03:44:35 <oerjan> Well, in Kayak and Lazy K, stdin turns into stdout according to how the program changes it.
03:44:49 * pikhq also wonders if that language is called INTERCAL
03:45:19 -!- ihope has quit (Connection timed out).
03:45:19 <pikhq> read(stdout);write(stdin, "whoo"); See? Evil.
03:45:20 <oerjan> Apart from the I/O commands being READ OUT and WRITE IN...
03:54:51 -!- zantrua has joined.
03:56:13 -!- zantrua has quit (Read error: 104 (Connection reset by peer)).
03:57:35 -!- zantrua has joined.
03:59:37 -!- zantrua has quit (Read error: 131 (Connection reset by peer)).
04:02:15 -!- bsmnt_bot has quit (Remote closed the connection).
04:02:18 -!- bsmnt_bot has joined.
04:04:07 -!- bsmnt_bot has quit (Excess Flood).
04:04:10 -!- bsmnt_bot has joined.
04:06:13 -!- bsmnt_bot has quit (Excess Flood).
04:06:20 -!- bsmnt_bot has joined.
04:06:49 -!- bsmnt_bot has quit (Excess Flood).
04:06:54 -!- bsmnt_bot has joined.
04:10:10 -!- bsmnt_bot has quit (Excess Flood).
04:10:15 -!- bsmnt_bot has joined.
04:10:33 -!- bsmnt_bot has quit (Excess Flood).
04:10:39 -!- bsmnt_bot has joined.
04:10:46 -!- bsmnt_bot has quit (Client Quit).
04:10:49 -!- bsmnt_bot has joined.
04:10:57 -!- bsmnt_bot has quit (Excess Flood).
04:11:05 -!- bsmnt_bot has joined.
04:11:55 <pikhq> ~exec sys.stdout("QUIT :Excess Flood")
04:12:20 <pikhq> ~exec self.raw("QUIT :Excess Flood")
04:12:20 -!- bsmnt_bot has quit (Client Quit).
04:12:22 <pikhq> That's what I meant.
04:12:24 -!- bsmnt_bot has joined.
04:12:30 -!- bsmnt_bot has quit (Excess Flood).
04:12:39 -!- bsmnt_bot has joined.
04:12:50 -!- bsmnt_bot has quit (Excess Flood).
04:12:59 -!- bsmnt_bot has joined.
04:13:43 -!- pikhq has quit ("leaving").
04:17:13 -!- calamari has quit ("Leaving").
04:28:32 -!- bsmnt_bot has quit (Excess Flood).
04:28:40 -!- bsmnt_bot has joined.
04:29:48 -!- bsmnt_bot has quit (Remote closed the connection).
04:29:52 -!- bsmnt_bot has joined.
04:30:23 -!- bsmnt_bot has quit (Excess Flood).
04:30:29 -!- bsmnt_bot has joined.
04:31:30 <oerjan> Good grief, "HNOP. Ashley Yakeley updated the status of HNOP, the Haskell library for doing nothing."
04:32:38 <oerjan> "It has recently been split into two Cabal packages: 'nop', a library of no-op services, and 'hnop', a program that uses nop to do nothing."
04:32:43 -!- bsmnt_bot has quit (Excess Flood).
04:32:46 -!- bsmnt_bot has joined.
04:33:15 <oerjan> And strangely enough it is _not_ merely a joke.
04:34:25 -!- bsmnt_bot has quit (Remote closed the connection).
04:34:27 -!- bsmnt_bot has joined.
04:34:34 -!- bsmnt_bot has quit (Remote closed the connection).
04:34:37 -!- bsmnt_bot has joined.
04:36:47 -!- bsmnt_bot has quit (Excess Flood).
04:37:01 -!- bsmnt_bot has joined.
04:37:19 -!- bsmnt_bot has quit (Excess Flood).
04:37:23 -!- bsmnt_bot has joined.
04:37:43 -!- bsmnt_bot has quit (Excess Flood).
04:37:51 -!- bsmnt_bot has joined.
04:38:27 -!- bsmnt_bot has quit (Remote closed the connection).
04:38:32 -!- bsmnt_bot has joined.
04:38:38 -!- bsmnt_bot has quit (Remote closed the connection).
04:38:44 -!- bsmnt_bot has joined.
04:39:23 -!- bsmnt_bot has quit (Remote closed the connection).
04:39:29 -!- bsmnt_bot has joined.
04:40:20 -!- bsmnt_bot has quit (Remote closed the connection).
04:40:25 -!- bsmnt_bot has joined.
04:40:46 -!- bsmnt_bot has quit (Remote closed the connection).
04:40:51 -!- bsmnt_bot has joined.
04:41:20 -!- oerjan has quit ("leaving").
04:42:05 <oklopol> maybe i'll make a language for doing nothing
04:42:45 -!- bsmnt_bot has quit (Remote closed the connection).
04:42:48 -!- bsmnt_bot has joined.
04:46:53 -!- bsmnt_bot has quit (Excess Flood).
04:46:58 -!- bsmnt_bot has joined.
04:47:08 -!- bsmnt_bot has left (?).
04:48:07 -!- bsmnt_bot has joined.
04:49:41 -!- bsmnt_bot has quit (Remote closed the connection).
04:49:48 -!- bsmnt_bot has joined.
04:50:07 -!- bsmnt_bot has quit (Remote closed the connection).
04:50:10 -!- bsmnt_bot has joined.
04:54:24 -!- bsmnt_bot has quit (Excess Flood).
04:54:33 -!- bsmnt_bot has joined.
04:54:37 -!- bsmnt_bot has quit (Remote closed the connection).
04:54:44 -!- bsmnt_bot has joined.
04:54:47 -!- bsmnt_bot has quit (Remote closed the connection).
04:54:53 -!- bsmnt_bot has joined.
04:55:52 -!- bsmnt_bot has quit (Remote closed the connection).
04:55:58 -!- bsmnt_bot has joined.
04:56:13 -!- bsmnt_bot has quit (Remote closed the connection).
04:56:24 -!- bsmnt_bot has joined.
04:56:50 -!- bsmnt_bot has quit (Client Quit).
04:56:53 -!- bsmnt_bot has joined.
05:00:01 -!- bsmnt_bot has quit (Excess Flood).
05:00:05 -!- bsmnt_bot has joined.
05:06:26 -!- bsmnt_bot has quit.
05:06:30 -!- bsmnt_bot has joined.
05:06:40 -!- bsmnt_bot has quit (Excess Flood).
05:06:46 -!- bsmnt_bot has joined.
05:11:55 -!- bsmnt_bot has quit (Remote closed the connection).
05:15:10 -!- bsmnt_bot has joined.
05:18:33 -!- bsmnt_bot has quit (Remote closed the connection).
05:18:35 -!- bsmnt_bot has joined.
05:19:34 -!- bsmnt_bot has quit (Remote closed the connection).
05:19:36 -!- bsmnt_bot has joined.
05:20:01 -!- bsmnt_bot has quit (Remote closed the connection).
05:20:53 -!- bsmnt_bot has joined.
05:21:26 -!- bsmnt_bot has quit (Remote closed the connection).
05:22:32 -!- bsmnt_bot has joined.
05:23:11 -!- bsmnt_bot has quit (Remote closed the connection).
05:23:13 -!- bsmnt_bot has joined.
05:26:39 -!- bsmnt_bot has quit (Read error: 131 (Connection reset by peer)).
05:26:42 -!- bsmnt_bot has joined.
05:27:30 -!- bsmnt_bot has quit (Remote closed the connection).
05:27:33 -!- bsmnt_bot has joined.
05:29:29 -!- bsmnt_bot has quit (Remote closed the connection).
05:29:31 -!- bsmnt_bot has joined.
05:30:28 -!- bsmnt_bot has quit (Remote closed the connection).
05:30:31 -!- bsmnt_bot has joined.
05:31:40 -!- bsmnt_bot has quit (Read error: 131 (Connection reset by peer)).
05:31:43 -!- bsmnt_bot has joined.
06:15:42 -!- bsmnt_bot has quit (Remote closed the connection).
06:16:07 -!- bsmnt_bot has joined.
06:16:19 -!- bsmnt_bot has quit (Remote closed the connection).
06:16:50 -!- bsmnt_bot has joined.
06:17:51 -!- bsmnt_bot has quit (Read error: 131 (Connection reset by peer)).
06:17:54 -!- bsmnt_bot has joined.
06:18:02 -!- bsmnt_bot has quit (Remote closed the connection).
06:18:04 -!- bsmnt_bot has joined.
06:18:11 -!- bsmnt_bot has quit (Remote closed the connection).
06:18:20 -!- bsmnt_bot has joined.
06:19:28 -!- bsmnt_bot has quit (Remote closed the connection).
06:19:43 -!- bsmnt_bot has joined.
06:19:44 <CakeProphet> it's always fun to imagine the semantics reducing to the most fundamental parts of the language.
06:21:58 <oklopol> This is great, my language is the nicest language I've ever seen for writing recursive data structures, but all you can do is nop :)
06:22:50 <oklopol> I guess the beautiful syntax and the nice way of structuring makes up for the fact you can't really do anything?
06:23:20 * CakeProphet is trying to find a clever languagge joke that won't offend anyone.
06:24:28 <oklopol> I'm not making a joke language.
06:25:17 <oklopol> This might actually be a very good language for teaching structures for example :)
06:25:49 <CakeProphet> a weird variation of lambda calculus might work for that.
06:26:09 <oklopol> I still haven't understood that language
06:27:02 <CakeProphet> but in general.... it's a very clear demonstration of how invidual basic parts can be grouped together to form abstracted procedures.
06:27:44 <CakeProphet> if you assign certain strings of lambdas a given name... and substitute the name instead of the functions whenever they arise
06:28:37 <CakeProphet> and continue doing that... you can quickly amass a logical stucture.
06:29:12 <CakeProphet> quick always seems to be the most powerful way to demonstrate abstraction.
06:31:36 <oklopol> hmm... what is the most complex thing written in lambda calculus?
06:56:10 -!- Sgeo has quit (Remote closed the connection).
07:24:27 -!- ShadowHntr has quit ("End of line.").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:53:25 -!- sebbu has joined.
10:49:46 -!- tgwizard has joined.
11:12:05 -!- jix has joined.
11:13:15 -!- jix has quit (Client Quit).
12:40:44 -!- jix has joined.
12:56:03 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
12:59:14 -!- jix has joined.
13:04:51 -!- andreou has joined.
13:48:56 -!- ihope has joined.
13:49:18 -!- ihope has quit (Client Quit).
14:10:02 -!- andreou has quit ("BitchX: faster than a speeding bullet, more powerful than a locomotive").
14:10:26 -!- andreou has joined.
15:53:04 -!- ihope has joined.
15:54:16 <ihope> ~exec self.raw("PRIVMSG #esoteric :uelauelaue")
15:57:15 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
16:24:40 <ihope> bsmnt_bot: exec self.raw("PRIVMSG #esoteric laueluaeleualeu")
16:52:45 <andreou> eh how do i find any ircops? /who -what?
17:21:57 -!- andreou has quit ("recycle").
17:33:26 -!- andreou has joined.
17:41:52 <ihope> Or something else. Lemme see...
17:43:15 <ihope> I guess /who *@freenode/staff*
17:44:02 <ihope> Then it's probably/who *freenode/staff*
17:45:04 <andreou> the latter is true, i found a few, but they're all idle :)
17:45:48 <ihope> notabot might not be.
18:03:39 -!- CakeProphet has quit ("haaaaaaaaaa").
18:28:37 -!- ShadowHntr has joined.
18:38:51 -!- digital_me has joined.
18:41:27 <ihope> bsmntbombdood: congrats, you just expressed the standard definition of an ordered pair in lambda calculus in Haskell notation.
18:53:11 <bsmntbombdood> and why doesn't my_map f list = cons (f (car list)) (my_map f (cdr list)) work?
19:20:55 <ihope> Lists would be completely different.
19:21:42 <ihope> A list would be represented as its own foldr function.
19:23:39 <ihope> cons x xs = \c e -> c x (xs c e)
19:24:09 <ihope> foldr c e xs = xs c e
19:24:40 -!- andreou has quit ("-").
19:25:16 <ihope> I think that's how lists are generally represented in lambda calculus.
19:25:22 <ihope> That's the typable way.
19:26:05 <ihope> And by typable way, I mean using Haskell's type system.
19:27:06 <ihope> Either the Hindley-Milner type system or the Damas-Milner type system. Both different names for the same thing, I think.
19:29:53 -!- CakeProphet has joined.
20:01:37 -!- ihope has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
20:04:13 <SimonRC> I accidently discovered a simple way of turing algebraic datatypes into collections of lambda calculus functions.
20:04:37 <SimonRC> Each value of the type takes one function per constructor.
20:05:31 <SimonRC> A constructor calls one of its arguments with the containted data and ignores the other arguments.
20:05:52 <SimonRC> e.g. a list datum takes two arguments.
20:06:46 <SimonRC> The first is called for a cons, and is passed the car and cdr of the list. The second is called for a nil and takes no arguments.
20:07:18 <SimonRC> cons a b = (\x y -> x a b)
20:55:14 -!- Sgeo has joined.
21:34:11 -!- andreou has joined.
21:40:16 -!- jix__ has joined.
21:43:21 -!- jix__ has changed nick to jix.
21:57:56 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:02:09 -!- sebbu has quit (Read error: 110 (Connection timed out)).
22:31:36 <ShadowHntr> i'd much rather do that in FORTRAN... ;)
22:33:46 -!- wooby has quit.
22:36:30 <CakeProphet> Is this the proper regex pattern for an ORK class definition?
22:36:32 <CakeProphet> re.compile(r"there is such a thing as an? (?P<name>.*?)\.? *$(?P<body>(.*?$)*)", re.MULTILINE|re.IGNORECASE)
22:37:44 <CakeProphet> re.compile(r"there is such an? (?P<metaclass>.*?) as an? (?P<name>.*?)\:? *$(?P<body>(.*?$)*)", re.MULTILINE|re.IGNORECASE)
22:37:58 <CakeProphet> I forgot the first part ends with a colon... and that I'm including metaclasses :D
22:53:24 -!- ihope has joined.
22:59:14 <ihope> Well, almost, anyway.
22:59:28 <ihope> It's just a little bit off
22:59:46 <ihope> Now, care to tell me just what it is that looks about right?
23:00:17 <CakeProphet> "there is such an? (?P<metaclass>.*?) as an? (?P<name>.*?)\:? *$(?P<body>(.*?$)*)" with multiline and ignorecase turned on.
23:02:42 * CakeProphet is written an ORK interpreter... and then adding some crap to it to create the Sophia dialect.
23:04:32 <CakeProphet> I meant "is writing"... but that sounds nifty.
23:04:50 -!- wooby has joined.
23:05:08 <CakeProphet> I mean also include inheritance... but maybe not directly.
23:05:48 <CakeProphet> or it could just be "There is such a <metaclass> as a <class> which is a <superclass>" which doesn't quite sound as ORKY as I'd like it to.
23:06:06 <CakeProphet> ORK is verbose in a terse way... that's getting a little superfluous. ;)
23:07:23 -!- andreou has quit ("recycling").
23:10:57 <ihope> Superfluously verbose terseness?
23:12:31 <CakeProphet> each statement is nice and direct... but overly verbose too.
23:12:50 <CakeProphet> with the inheritance add-on I just proposed... it would sound less to the point
23:13:31 -!- andreou has joined.
23:14:26 <ihope> Can you put that in words less than four letters long?
23:15:21 <CakeProphet> nah... it's not length that's the problem.
23:15:45 <CakeProphet> There is such a thing as a master of all beings which is an apple
23:16:04 <CakeProphet> there is such a thing as a master of all beings
23:19:41 <CakeProphet> There is such a thing as a master of all beings
23:19:50 <CakeProphet> a master of all beings is very much like an apple
23:24:56 <andreou> can anyone get ftp://ftp.cs.bris.ac.uk/pub/goedel/latest/goedel-src.tar.Z or is the FTP boinked?
23:26:34 <CakeProphet> hmm.. I always have a hard time understand how declarations slow down execution speed... they still need to be computed.
23:31:49 -!- andreou has quit ("new /netbsd, rejoice").
23:35:41 -!- pikhq has joined.
23:39:13 -!- andreou has joined.
23:44:05 -!- tgwizard has quit (Connection timed out).