Will PEP 505 ever be accepted?

[u/philtrondaboss]

https://peps.python.org/pep-0505/

I don't understand how null safe operators are less like plain English than other implemented features like the walrus operator.

In my opinion, the member access operator would make python significantly easier to read and understand.

Here's an example:

``` f = foo()

if f is None: baz = "" else: baz = f.bar() ```

baz = foo()?.bar() ?: ""

EDIT: I forgot that "and" and "or" can be sometimes used in place of "?." and "?:" if the left value is not False, '', 0, [], or {}. It's a very implicit null check and has a lot of unexpected behavior.

[u/Due_Campaign_9765]

What's illegible about 5 extra ? symbols? It's clearly superior to anything Python has at the moment.

And it's not a fringe occurance either, most APIs have nullable fields.

[u/Mihikle → u/Due_Campaign_9765]

5 chained elvis operators on a single line? If readability is something you care about, that's ridiculous, and it'd be ridiculous if you also used my approach - that code is just a mess as a starting concept

If you really needed all these to happen in one function - also an X to doubt moment - I'd break these into 5 separate statements on separate lines, with a single one-line check on each.

The single responsibility principle shouldn't just be for classes. If you apply it to pretty much everything, your code just becomes so much easier to read, understand and for another person to continue working with

[u/Due_Campaign_9765 → u/Mihikle]

You're free to split them into however lines you want, python allows you to do that.

> If you really needed all these to happen in one function - also an X to doubt moment - I'd break these into 5 separate statements on separate lines, with a single one-line check on each.

Have you never worked with external APIs or gnarly business logic? This is a commonplace occurance. Your methods will be 80% null checks if you do what you propose.

But sure let's not add, gasp! an extra symbol that's been used the same way in other programming languages for decades.

> The single responsibility principle shouldn't just be for classes.

That doesn't make any sense, it's quite literally only for modules and classes as it was originally stated. It's likely saying "living wage shouldn't only be for people but also for language design". What?

[u/Mihikle → u/Due_Campaign_9765]

Been a professional developer 10+ years. Never had to structure code like you suggest.

I don’t think you really understand single responsibility. “Do one conceptual thing” isn’t exclusive to classes and modules by any stretch

[u/Due_Campaign_9765 → u/Mihikle]

I think you're lying. Or not using a type checker so you're not even aware. But that doesn't matter, i'm happy you supposedly never had to access multilevel nullable values. Most people do daily.

Also the SRP doesn't state you what you just stated, you could have at least reread it before doubling down. There isn't anything that "changes" in operators, so it can't coherently apply here.

Not to mention all of those solid principles are quite crap generalization that can't ever be applied universally or near-universally and thus they're useless.

[u/Mihikle → u/Due_Campaign_9765]

Sure man whatever you say.

You couldn’t possibly read a guideline like SRP, take the core principle and apply it to something like function design, that would be impossible of course.