Vitja Makarov | 5 Jul 09:17 2011

Re: [Cython] PEP 3135 -- New Super

2011/7/5 Stefan Behnel <stefan_ml@...>:
> Vitja Makarov, 05.07.2011 08:21:
>> I was thinking about implementing new super() with no arguments.
> Please do :)
> If you start working on it, please assign the ticket to you:

Ok, I'll do this if I start.

>> The problem is where to store __class__, I see two options here:
>> 1. Add func_class member to CyFunction, this way __class__ will be
>> private and not visible for inner functions:
>> 2. Put it into closure
> The second option has the advantage of requiring the field only when super()
> is used, whereas the first impacts all functions.
> I would expect that programs commonly have a lot more functions than
> specifically methods that use a no-argument call to super(), so this may
> make a difference.

So, now classes are created the following way:

class_dict = {} = foo_func
class = CreateClass(class_dict)

So after class is created I should check its dict for CyFunction
members (maybe only ones that actually require __class__)
and set __class__:

for value in class.__dict__.itervalues():
   if isinstance(value, CyFunction) and value.func_class is WantClass:
       value.func_class = class

> OTOH, not all methods have a closure, so creating one just to store the
> "__class__" field is very wasteful, in terms of both runtime and memory
> overhead. A lot more wasteful than paying 8 bytes of memory for each
> function, with no additional time overhead.

Going this way it only requires to initialize closure:

closure.func_class = class

Btw, first way requires cyfunction signature change, it would accept
cyfunction object as first argument.
This also could help to solve default args problem.

>> And I don't think that __class__ should be use somewhere outside super()
> Agreed. CPython simply uses a compile time heuristic ("is there a function
> call to something global named 'super'?") when creating this field, so it's
> strictly reserved for this use case.
> BTW, I like the irony in the fact that CPython essentially gives Cython
> semantics to the "super" builtin here, by (partially) evaluating it at
> compile time.

Yeah, I think Cython super with no args should be a little bit faster
then classic one.