Generators probably. It’s the one thing i genuinely miss about python when i work in rust.

Ick. At the very least, i’ve seen it a LOT less in VSC. The fact that something as simple as rainbow brackets uses the freemium model in intellij sucks. I mean the fact that it’s not a builtin setting is dumb too but that’s beside the point

I feel like it’s like pointers.

“Variable” refers to the label, i.e. a box that can contain anything (like *ptr is a pointer to [something we dont know anything about])

Immutable describes the contents, i.e. the stuff in the box cant change. (like int* ptr describes that the pointer points to an int)

Rust makes it very obvious that there’s a difference between constants and immutable variables, mainly because constants must be compile time constants.

What do you call it when a variable cant change after its definition, but isnt guaranteed to be the same on each function call? (E.g. x is an array that’s passed in, and we’re just checking if element y exists)

It’s not a constant, the contents of that label are “changing”, but the label’s contents cant be modified inside the scope of that function. So it’s a variable, but immutable.

The freemium and constant “are you sure you dont want to pay?” from some intellij plugins is insulting enough that it’s hard to believe any developer would praise it. Presumably this doesnt happen in vscode because it cant happen in vscode, not because people arent shameless enough to do it there.

code that’s been written today has been made obsolete by a language feature in the latest nightly build

I mean couldnt you say that about any language? There’s lots of old C code that’s obsoleted by features in C11. There’s lots of stuff written in python today that’s obsoleted by stuff in the 3.13 alpha. It’s just kinda how things go.

Doesnt the edition system prevent this from being too big of an issue anyway?

Counterpoint, i didnt like the rust book at all (as an inexperienced self taught ~6 months to a year into learning python at the time). Programming Rust and Rust In Action were far better.

Seems you missed the last line

compiles to fast code

Obligatory shoutout to Qownnotes for being excellent, fully open source, and with owncloud integration.

15532 on-type format (, by adding closing ) automatically

Thank fucking god lmao. The PR specifically mentions the Some( case too, which is exactly where i encounter this the most.

Overall very nice changes

Here’s the script. It’s nothing fancy, and iirc it only works for top level functions/classes. That means you still have to take care of attributes and methods which is a little annoying, but for simple stuff it should save a bit of time.

For downsides, i’d like to add that the lack of function overloading and default parameters can be really obnoxious and lead to [stupid ugly garbage].

A funny one i found in the standard library is in time::Duration. Duration::as_nanos() returns a u128, Duration::from_nanos() only accepts a u64. That means you need to explicitly downcast and possibly lose data to make a Duration after any transformations you did.

They cant change from_nanos() to accept u128 instead because that’s breaking since type casting upwards has to be explicit too (for some reason). The only solution then is to make a from_nanos_u128() which is both ugly, and leaves the 64 bit variant hanging there like a vestigial limb.

Pyo3 doesnt generate type hints at all iirc. There’s some more info here

The gist, as i recall, is that you’re supposed to maintain a .pyi file in the rust project folder that gets automatically added in by maturin when building. I’m no regex wizard, but i was able to whip together a small script that generates simple function and class stubs that also have the rust docstring. Iirc they’re planning on adding some official support for generating type hints, but i have no idea how far along it is or where it is on the priority list

It’s most useful when you’re using some data you already have as the dictionary key. A usecase i had for this was a binary file parser with 10 types of event markers. It was originally coded with if/elif, but performance was a pretty big consideration. Using the event markers as keys to a dictionary dispatch improved performance by about 15% and made the code significantly more readable.