Question

I would like a class whose instances return a value when called directly as if they inherit from int, float, str, etc. I imagine it’s overloading some function ???:

class A(object):
    def __init__(self, value):
        self.value = value

    def somefunction(self):
        if isintance(self.value, int):
            return 5
        else:
            return 'something else'

    def __???__(self):
        return self.value

a = A(2)
a + 5 # 7
a.somefunction() # 5

a = A('foo')
a + "bar" # 'foobar'
a.somefunction() # 'something else'

I can’t simply subclass int as the value could be of different types.

Is this doable? Perhaps there’s a good reason that this can’t be done, but it’s late, and I can’t think of it. Thanks in advance.

Answer 1

Overriding __getattr__ won’t work because of metaclass confusion; the issue is that the relevant methods need to be in the instance’s class dict.

If you’re happy with value being immutable, one way could be to override __new__ and construct classes on demand:

def __new__(cls, value):
    return type("A", (type(value), A), {})(value)

Note that this puts A after type(value) in the mro; this is necessary to stop __new__ resulting in runaway recursion! If there’s methods on A that should override those on type(value), you can put them into the dict 3rd argument to type().