CODEWITHSUNDEEP
pythonpython-decoratorsfunction-composition
RussAbbott
RussAbbott

Reputation: 2738

A function composition operator in Python

In this question I asked about a function composition operator in Python. @Philip Tzou offered the following code, which does the job.

import functools

class Composable:

    def __init__(self, func):
        self.func = func
        functools.update_wrapper(self, func)

    def __matmul__(self, other):
        return lambda *args, **kw: self.func(other.func(*args, **kw))

    def __call__(self, *args, **kw):
        return self.func(*args, **kw)

I added the following functions.

def __mul__(self, other):
    return lambda *args, **kw: self.func(other.func(*args, **kw))

def __gt__(self, other):
    return lambda *args, **kw: self.func(other.func(*args, **kw))

With these additions, one can use @, *, and > as operators to compose functions. For, example, one can write print((add1 @ add2)(5), (add1 * add2)(5), (add1 > add2)(5)) and get # 8 8 8. (PyCharm complains that a boolean isn't callable for (add1 > add2)(5). But it still ran.)

All along, though, I wanted to use . as a function composition operator. So I added 

def __getattribute__(self, other):
    return lambda *args, **kw: self.func(other.func(*args, **kw))

(Note that this fouls up update_wrapper, which can be removed for the sake of this question.)

When I run print((add1 . add2)(5)) I get this error at runtime: AttributeError: 'str' object has no attribute 'func'. It turns out (apparently) that arguments to __getattribute__ are converted to strings before being passed to __getattribute__.

Is there a way around that conversion? Or am I misdiagnosing the problem, and some other approach will work?

Upvotes: 7

Views: 6366

Answers (3)

Dillon Davis
Dillon Davis

Reputation: 7740

You can step around the limitation of defining composable functions exclusively in the global scope by using the inspect module. Note that this is about as far from Pythonic as you can get, and that using inspect will make your code that much harder to trace and debug. The idea is to use inspect.stack() to get the namespace from the calling context, and lookup the variable name there.

import functools
import inspect

class Composable:

    def __init__(self, func):
        self._func = func
        functools.update_wrapper(self, func)

    def __getattr__(self, othername):
        stack = inspect.stack()[1][0]
        other = stack.f_locals[othername]
        return Composable(lambda *args, **kw: self._func(other._func(*args, **kw)))

    def __call__(self, *args, **kw):
        return self._func(*args, **kw)

Note that I changed func to _func to half-prevent collisions should you compose with a function actually named func. Additionally, I wrap your lambda in a Composable(...), so that it itself may be composed.

Demonstration that it works outside of the global scope:

def main():
    @Composable
    def add1(x):
        return x + 1

    @Composable
    def add2(x):
        return x + 2

    print((add1.add2)(5))

main()
# 8

This gives you the implicit benefit of being able to pass functions as arguments, without worrying about resolving the variable name to the actual function's name in the global scope. Example:

@Composable
def inc(x):
    return x + 1

def repeat(func, count):
    result = func
    for i in range(count-1):
        result = result.func
    return result
    
print(repeat(inc, 6)(5))
# 11

Upvotes: 2

Philip Tzou
Philip Tzou

Reputation: 6438

I am actually unwilling to provide this answer. But you should know in certain circumstance you can use a dot "." notation even it is a primary. This solution only works for functions that can be access from globals():

import functools

class Composable:

    def __init__(self, func):
        self.func = func
        functools.update_wrapper(self, func)

    def __getattr__(self, othername):
        other = globals()[othername]
        return lambda *args, **kw: self.func(other.func(*args, **kw))

    def __call__(self, *args, **kw):
        return self.func(*args, **kw)

To test:

@Composable
def add1(x):
    return x + 1

@Composable
def add2(x):
    return x + 2

print((add1.add2)(5))
# 8

Upvotes: 5

Martijn Pieters
Martijn Pieters

Reputation: 1121524

You can't have what you want. The . notation is not a binary operator, it is a primary, with only the value operand (the left-hand side of the .), and an identifier. Identifiers are strings of characters, not full-blown expressions that produce references to a value.

From the Attribute references section:

An attribute reference is a primary followed by a period and a name:

attributeref ::=  primary "." identifier

The primary must evaluate to an object of a type that supports attribute references, which most objects do. This object is then asked to produce the attribute whose name is the identifier.

So when compiling, Python parses identifier as a string value, not as an expression (which is what you get for operands to operators). The __getattribute__ hook (and any of the other attribute access hooks) only has to deal with strings. There is no way around this; the dynamic attribute access function getattr() strictly enforces that name must be a string:

>>> getattr(object(), 42)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: getattr(): attribute name must be string

If you want to use syntax to compose two objects, you are limited to binary operators, so expressions that take two operands, and only those that have hooks (the boolean and and or operators do not have hooks because they evaluate lazily, is and is not do not have hooks because they operate on object identity, not object values).

Upvotes: 6

Related Questions