A Crime Against Nature

Every so often, while writing Python, I've found myself wishing I could easily dispatch method calls according to the type of the arguments. The urge usually passes quickly, but... oh, the hell with it, there's no point trying to justify what I've done. Just look:

>>> import bondage
>>> 
>>> class C(object):
...   @bondage.discipline(int)
...   def foo(self, arg):
...     print 'int'
...   @foo.discipline(str)
...   def foo(self, arg):
...     print 'str'
...   @foo.discipline(int, str, int)
...   def foo(self, arg1, arg2, arg3):
...     print 'int, str, int'
... 
>>> c = C()
>>> c.foo(1)
int
>>> c.foo('a')
str
>>> c.foo(1, 'a', 1)
int, str, int
>>> c.foo([])
Traceback (most recent call last):
  File "", line 1, in <module>
  File "bondage.py", line 18, in <lambda>
    return lambda *args: self._dispatch(obj, *args)
  File "bondage.py", line 22, in _dispatch
    return self._argspecs[argspec](obj, *args)
KeyError: (<type 'list'>,)
>>> 

I'd like to make it clear that there is absolutely no excuse for perpetrating this sort of insanity, ever. With that said, here's how I did it:

class discipline(object):
    
    def __init__(self, *argspec):
        self._argspecs = {}
        self.discipline(*argspec)
    
    def discipline(self, *argspec):
        self._argspec = argspec
        return self
    
    def __call__(self, f):
        self._argspecs[self._argspec] = f
        return self

    def __get__(self, obj, objtype=None):
        return lambda *args: self._dispatch(obj, *args)

    def _dispatch(self, obj, *args):
        argspec = tuple(map(type, args))
        return self._argspecs[argspec](obj, *args)

Obviously it's a stupid implementation, and if you wanted to do this properly you'd have to pay attention to subtypes, and do something clever with numeric types, and... oh, God, what am I saying?

Enough!

If you really want to do this "properly", use some other language where it's already built in, and begone.

The Joy of Self

I have a distant and fuzzy memory, from back in the day... when I was but a wee slip of a lad, sallying forth to do battle with million-line C++ monstrosities (and just barely escaping with my sanity intact purple monkey dishwasher), I came upon a Path class. It was probably called CPath: classes were new and shiny, so far as any of us knew at the time, and absolutely deserved a prefix to underline their special status. Look, ma, I'm programming Object Orientedly!

And, yeah, it was horrible. Big, clunky, confusing... I'd like to say that the blistering speed made up for it all, but that would be entirely untrue. It was nasty.

As a result of this, I had never since felt the slightest urge to create a Path class of my own... until today. I was trying to get an overgrown build script under control, and - despite my scars - it suddenly seemed like a good idea.

So I had a go.

And... well, this sort of thing is why I love Python, and is also the clearest illustration I've yet seen of why explicit self is a Good Thing. The following code is, as usual, hacked up from memory and may therefore contain hilariously deadly bugs; caveat lector.

import os, shutil

class Path(str):

    def __new__(cls, path):
        abs_ = os.path.abspath(path)
        norm = os.path.normpath(abs_)
        return str.__new__(cls, norm)

    exists = property(os.path.exists)
    isfile = property(os.path.isfile)
    isdir = property(os.path.isdir)
    # etc...

    move = shutil.move
    listdir = os.listdir
    # etc...

    def __getattr__(self, name):
        return self.join(name)

    def join(*args):
        return Path(os.path.join(*args))

    def delete(self):
        if self.isdir:
            shutil.rmtree(self)
        else:
            os.remove(self)
    # etc...

Now, IMO, this was a massive win: I made the client code a lot less verbose, and hence clearer, and I did most of the work by trivially subclassing a builtin type and dropping in a bunch of standard library functions as methods. The real one has many more bells and whistles (in fact, I think I got a bit carried away) but hopefully you get the idea.

The crucial point is that I couldn't have done it so neatly without explicit self; also, amusingly, most of the explicit selfs in this class are in fact implicit. So there.