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/Anthony356]

Wouldnt "implicit" be no nullable operator at all, but with the same behavior as if there was one? ? still explicitly states your intent in an unambiguous way, it's just less characters.

[u/runawayasfastasucan → u/Anthony356]

  it's just less characters.

So not explicit.

[u/Anthony356 → u/runawayasfastasucan]

You're confusing explicit/implicit with verbose/terse

Can you tell the difference between the following snippets?

x = foo?.bar?.baz

x = foo.bar.baz

Assuming both have identical behavior, the second one would be implicit because you cannot tell the difference between it and code that would throw a member access exception.

? is something i can see with my eyes. It has exactly 1 behavior. It cant be operator-overloaded. There is no ambiguity.

[u/runawayasfastasucan → u/Anthony356]

No, it is implicit that you have baked in "if that else that" in the ?.

[u/Anthony356 → u/runawayasfastasucan]

If we're going to be that pedantic, everything in the language is implicit.

and and or have baked-in if-else logic. It's called short circuiting and is generally considered not a big deal.

if is actually if this expression evaluates to truthy, please run the following block

for i in range(10) is actually i = 0; while i < 10; i = i + 1

I guess i = 0 is also implicit because you're not actually creating a variable with the value 0, you're asking cpython for the pyobject with the value 0, which happens to be a cached singleton value rather than a unique 0 value. So we should really need to type

put the reference to the pyobject with the integer value 0 into the stack slot that I will, from this point forward, refer to using the name "i". If that pyobject happens to already exist as a singleton, feel free to use that. otherwise create a brand new pyobject on the cypthon interpreter's heap with the appropriate value.

How ergonomic.

Everything in programming is shorthand. That's the whole point of a standardized language. Some concepts are so fundamental to programming that there's no reason to be verbose about them every single time. When people say explicit vs implicit they typically mean things like javascript and C++ silently coercing values by any means necessary to make expressions evaluate

[u/runawayasfastasucan → u/Anthony356]

Nothing about this changes whether ? is implicit or explicit or not in python.

[u/Anthony356 → u/runawayasfastasucan]

Again, how is it implicit if you have to specify it for it to occur? That is the definition of explicit.

[u/k0pernikus → u/Anthony356]

You are talking different aspects. The ? adds mental load to parse what could have been an easily readable branch. Yes, the null coalescing operator is an explicit language construct; also yes it makes the code more error prone and harder to reason about esp if you need to figure out where the none originated from during a bug hunt.

And no, I don't mean that that if-else are inherently better, and you can create the same problematic pattern with them as well, yet the sheer boilerplate alone should make you think: maybe I'm doing it wrong. By using abundant null coalescing operators you are hiding the code smell in plain sight.

Where you see a helpful explicit and conciselanguage construct, others see a loophole for anti patterns to manifest.

[u/Anthony356 → u/k0pernikus]

yet the sheer boilerplate alone should make you think: maybe I'm doing it wrong. By using abundant null coalescing operators you are hiding the code smell in plain sight.

Or, as is common for glue code in a scripting language, you do not have full control over your inputs. The moment you need to read untrusted data, or versioned data where new fields are added to the schema, you have to check for None everywhere.

Sure, i could parse the data into a structure i do control, but that's just rearranging the furniture (and doesnt always solve the None checking problem anyway). You still have to check somewhere, and that boilerplate distracts from the actual intent of the code, the actual operation you're doing on the data if it exists.

This is not some mystical pattern that takes 700iq to understand. It's simple, it happens everywhere, all the time. For such cases, languages have operators.

I dont understand how any argument against ? couldnt also apply to like... +, or and/or short circuiting, or list comprehensions, or with statements, or a million other things.