[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Python-Dev] PEP 575 (Unifying function/method classes) update

On 2018-05-15 18:36, Petr Viktorin wrote:
> Naturally, large-scale
> changes have less of a chance there.

Does it really matter that much how large the change is? I think you are 
focusing too much on the change instead of the end result.

As I said in my previous post, I could certainly make less disruptive 
changes. But would that really be better? (If you think that the answer 
is "yes" here, I honestly want to know).

I could make the code less different than today but at the cost of added 
complexity. Building on top of the existing code is like building on a 
bad foundation: the higher you build, the messier it gets. Instead, I 
propose a solid new foundation. Of course, that requires more work to 
build but once it is built, the finished building looks a lot better.

> With such a "finished product" PEP, it's hard to see if some of the
> various problems could be solved in a better way -- faster, more
> maintainable, or less disruptive.

With "faster", you mean runtime speed? I'm pretty confident that we 
won't lose anything there.

As I argued above, my PEP might very well make things "more 
maintainable", but this is of course very subjective. And "less 
disruptive" was never a goal for this PEP.

> It's also harder from a psychological point of view: you obviously
> already put in a lot of good work, and it's harder to waste that work if
> an even better solution is found.

I hope that this won't be my psychology. As a developer, I prefer to 
focus on problems rather than on solutions: I don't want to push a 
particular solution, I want to fix a particular problem. If an even 
better solution is accepted, I will be a very happy man.

What I would hate is that this PEP gets rejected because some people 
claim that the problem can be solved in a better way, but without 
actually suggesting such a better way.

> Is a branching class hierarchy, with quite a few new of flags for
> feature selection, the kind of simplicity we want?

Maybe yes because it *concentrates* all complexity in one small place. 
Currently, we have several independent classes 
(builtin_function_or_method, method_descriptor, function, method) which 
all require various forms of special casing in the interpreter with some 
code duplication. With my PEP, this all goes away and instead we need to 
understand just one class, namely base_function.

> Would it be possible to first decouple things, reducing the complexity,
> and then tackle the individual problems?

What do you mean with "decouple things"? Can you be more concrete?

> The class hierarchy still makes it hard to decouple the introspection
> side (how functions look on the outside) from the calling mechanism (how
> the calling works internally).

Any class who wants to profit from fast function calls can inherit from 
base_function. It can add whatever attributes it wants and it can choose 
to implement documentation and/or introspection in whatever way it 
wants. It can choose to not care about that at all. That looks very 
decoupled to me.

> Starting from an idea and ironing out the details it lets you (and, if
> since you published results, everyone else) figure out the tricky
> details. But ultimately it's exploring one path of doing things ? it
> doesn't necessarily lead to the best way of doing something.

So far I haven't seen any other proposals...

> That's a good question. Maybe inspect.isfunction() serves too many use
> cases to be useful. Cython functons should behave like "def" functions
> in some cases, and like built-in functions in others.

 From the outside, i.e. user's point of view, I want them to behave like 
Python functions. Whether it's implemented in C or Python should just be 
an implementation detail. Of course there are attributes like __code__ 
which dive into implementation details, so there you will see the 

> before we change how inspect.isfunction ultimately behaves,
> I'd like to make its purpose clearer (and try to check how that meshes
> with the current use cases).

The problem is that this is not easy to do. You could search CPython for 
occurrences of inspect.isfunction() and you could search your favorite 
Python projects. This will give you some indication, but I'm not sure 
whether that will be representative.

 From what I can tell, inspect.isfunction() is mainly used as guard for 
attribute access: it implies for example that a __globals__ attribute 
exists. And it's used by documentation tools to decide that it should be 
documented as Python function whose signature can be extracted using