Saturday 16 February 2008

Brand new blog engine without a single line of code

Having investigated the new Google D&S forms feature, I decided to create a proof-of-concept blog application (OK - calling it an application is a *bit* an overstatement). It has some basic features, like form for entering entries and a feed. I doesn't have a site and is pretty much crippled. Still, quite good for 0 lines of code.

Here's the feed

And here's the new entry form. Feel free to post.

Sunday 3 February 2008

Implementing Arc's function-negation operator in Python

Hey look! This guy implemented Arc's function-negation operator in Chicken. And he claims to be a Pythoneer, traitor ;-) !

I just investigated the possibilities of doing more or less the same thing in Python. Of course: you can't change the syntax, and you can't change default function's behaviour (which is not having "~" operator implemented). Or can't you?

Let's start with something more explicit for a moment. Nothing prevents us from creating a callable decorator that implements __invert__ something like this:

class invertible:

def __init__(self, foo):
self.foo = foo

def __call__(self, *args, **kwargs):
return self.foo(*args, **kwargs)

def __invert__(self):
def wrapper(*args, **kwargs):
return not self.foo(*args, **kwargs)
return wrapper
Implementing __init__ enables us to call invertible() with an argument, and implementing __call__ makes the instances of our class callable. These two work together in a way that an ordinary decorator works: It's a callable, that takes a callable and returns another callable - easy, huh?
Implementing __invert__ lets us use the "~" operator on the instances of our class, like this:
truth = invertible(lambda: True)
not_truth = ~truth
assert truth()
assert not not_truth()
This implementation, even though it's easy, is not finished yet. The inverted value is a regular function, which means, that we couldn't invert it again. The easy solution to that is decorating the wrapper:
class invertible:
# ...
def __invert__(self):
@invertible
def wrapper(*args, **kwargs):
return not self.foo(*args, **kwargs)
return wrapper
But this would cause the wrappers to accumulate on inverting. We can also check explicitly if we get an invertible on input and set a switch on each instance
class invertible:

def __init__(self, foo):
self.foo = foo
self.inverted = False

def __call__(self, *args, **kwargs):
if self.inverted:
return not self.foo(*args, **kwargs)
else:
return self.foo(*args, **kwargs)

def __invert__(self):
ret = invertible(self.foo)
ret.inverted = (not self.inverted)
return ret
Now, with the decorator ready, you can do some *evil* magic with frames and namespaces in order to decorate everything in scope, but I'm leaving it as an exercise to readers ;P