Rust generics can be written in a more compact way, fn f(x: impl Test) { ... } Is basically the same as fn f<T: Test>(x: T) { ... } Having to annota

Rust generics can be written in a more compact way, fn f(x: impl Test) { ... } Is basically the same as fn f<T: Test>(x: T) { ... } Having to annotate the return value of functions is partly to make sure don't break semver accidentally, but it also constrains type inference to a local search rather than global search, avoiding spooky action at distance (when modifying a function changes the signature of another function). It seems that semver hazards are more important in languages with static types. That pub? It's punching waaay above its weight! Having things private by default protects against semver hazards too, but it's also the major tool that enable writing safe code that uses unsafe { .. } blocks underneath. That's because a single unsafe block typically taints the whole module it's contained (such that even safe code needs a safety review). Being able to write safe abstractions of unsafe code is the pull of Rust so people need to get it right. For example, setting the field len of a Vec to a value larger than what's initialized in its buffer will cause UB when accessing that memory; if this field weren't private, making a safe Vec would be impossible (likewise, a function that could set the len to any value must be private, etc). So pub can only be used for things that are safe to export, and people should be careful with that. Here's my least favorite syntax from there: that damn Ok(..). Ok-wrapping sucks. There were proposals to remove it, but they were rejected. There's a library that removes it [0], and people should use it. It also makes the Result<..> return type implicit in the function signature too. [0] https://boats.gitlab.io/blog/post/failure-to-fehler/#but-about-fehler https://boats.gitlab.io/blog/post/failure-to-fehler/#but-abo...