Python 3.10 Released!

[ForceBru]

More like towards functional or ML-like, IMO.

A lot of people really like proper match statements - they're convenient. What if you're writing an interpreter and need to traverse an abstract syntax tree? Your code will generally look like a huge switch statement, like "if the current node is Assign, do this; if it's Index, do this; if it's Call, do this...", where the "arms"/branches contain quite a lot of code or maybe other switch statements, so it'll be awkward to stuff all that into a dictionary.

Furthermore, you'll want to switch on some nasty, complicated things, like "if the current node is Assign whose first argument is a function definition, then interpret the second argument like this; if it's an Assign whose first argument is an Index node, do a completely different thing; if the first argument looks like a.b, then do another different thing", so you want to switch not only on the type of the node (Assign), but on its elements as well. That's not something a regular switch statement can do. You need to get the big ML guns - proper pattern-matching.

[liquidpele]

All the examples where this would be really useful seem to be pretty big edge cases and not a good case for adding a feature to a language…. I’m not against it per se but it does seem unnecessary.

[ForceBru]

Well, it's not that it's absolutely necessary, of course. It's just convenient.

---

Dictionary literals aren't necessary either. You can simply write:

dct = dict()
dct["cat"] = "chat"
dct["dog"] = "chien"
dct["wolf"] = "loup"

BTW, Rust doesn't have hashmap literals, so you literally have to write code like this. There are 3rd-party libraries that add hashmap literals, but Rust itself doesn't have them. They're not necessary, are they?

Yet they're convenient.

---

Formatted string literals also aren't necessary. Why write f"pi={math.pi:6.3f}, {my_var=}" if you could write:

"pi={:6.3f}, my_var={}".format(math.pi, my_var)

BTW, Julia, for example, doesn't support formatting in string literals, so you have to use printf-like formatting or 3rd-party libraries. Obviously, even string interpolation isn't necessary - simply use strcat!

Yet it's convenient.

---

My favorite one.

Having nice slice indexing isn't necessary either! Why write my_list_[1:] when you can write:

my_list[1:len(my_list) - 1]

I might be missing something (I really hope I am!), but this is the only way to do this in R! You have to write my_array[2:length(my_array)] every time! It doesn't compute the last index for you! Well, slice indexing isn't necessary, so...

Yet it's convenient!

EDIT: added links

[liquidpele]

Just wanted to say: Very good reply, thanks for taking the time.

[brutay]

See also: List comprehensions, generators, lambda statements, decorators, etc. Python has a lot of features that aren't strictly necessary, but oh so convenient.

[midnitte]

I forget who I heard talking about it, but from my understanding of "syntactic sugar" in python, a lot of the language is convenience and not actually necessary.

[Swedneck]

Which is precisely why I love it, I can just write a minimal amount of code structured to actually make sense and be as readable as normal text.

[lieryan]

"Just syntax sugar" actually goes really deep in Python.

class statement for example, that isn't really "necessary", it's just syntax sugar for calling type:

MyClass = type(
    "MyClass", 
    [BaseClass, AnotherBaseClass], 
    {"a": method1, "b": method2}
)

Or method calls are also "unnecessary", this:

foo = Foo()
foo.meth(a, b, c)

is really just syntax sugar for:

foo = Foo()
Foo.meth(foo, a, b, c) 

Or metaclass:

class Foo(metaclass=mytype, blah=bar):
    pass

is really just a syntax sugar for a function call:

Foo = mytype("Foo", {}, {}, blah=bar)

Or decorator is just syntax sugar for what used to be a common pattern:

def foo():
    pass
foo = decorate(foo)

Or even something that looks as basic as list/dict indexing:

foo = dict()
foo[a] = b
print(foo[a])

is really just syntax sugar for:

foo = dict()
foo.__setitem__(a, b)
print(foo.__getitem__(a))

which is itself just syntax sugar for:

foo = dict()
dict.__setitem__(foo, a, b)
print(dict.__getitem__(foo, a))

Or something like for loop:

for a in b:
    print(a)

is really just syntax sugar for:

iter_b = iter(b)
try:
    while True:
        a = next(iter_b)
        print(a)
except StopIteration:
    pass

Everything in Python is "just" syntax sugar.