In some cases it would be really helpful to have a decorator which automagically casts returned value to a different type.

Particularly, instead of writing something like this:

def example():
    result = []

    for ...:
        result.append(item)

    return result

...this would do the magic:

@functools.cast(list)
def example():
    for ...:
        yield item

On the positive side (apart from its compactness) when an implementation changes from list to set, .append() does not need to be changed to .add().

Of course on the caller side one can always write list(example()) but sometimes this transformation needs to be done on implementation side for architectural reasons.

Pseudocode for proposed functools.cast():

def cast(type):
    def wrapper(func):
        @wraps(func)
        def newfunc(*args, **keywords):
            return type(func(*args, **keywords))

        return newfunc

    return wrapper

Currently, the closest functionality I can think of (using standard library functions only):

@functools.partial(lambda func: functools.wraps(func)(lambda *args, **keywords: list(func(*args, **keywords))))

Or without proper wrapping:

@functools.partial(lambda func: lambda *args, **keywords: list(func(*args, **keywords)))

First off, thanks for the suggestion!

But there are two things to say about this. One, that isn't actually casting as Python doesn't have the concept of casting like in statically typed languages since everything is dynamically typed.

Two, the solution is so short and simple but not widely needed enough that I don't think this warrants addition in the stdlib. And since you're changing what the function returns you probably need a new docstring anyway, which means having to do a normal wrapping of the function.

So thanks for the idea but I don't think we will be adding this to the stdlib (obviously feel free to put this up on PyPI or as a gist somewhere and share it in a blog post or something.