There's quite a bit more to Rust than this. Just for a few examples:
- All references must obey reader-writer-lock like semantics. This makes multi-threaded code a lot easier to write, and makes it easier to reason even about single-threaded code using references (spooky action at a distance from other side of the codebase is forbidden).
- Trait-based generics avoid both the incomprehensible compile-time or run-time errors of duck-typed generic code, and the performance cost of dynamic type erasure. In short, they make generic code both efficient and pleasant to write.
- Rust borrows lots of useful patterns from functional programming that are not typically found in imperative languages, e.g. immutability by default, pattern matching, closures, enum-based error handling... all that without losing the performance benefits of mutability or making imperative code a PITA to write.
- A well thought-out type inference system avoids cluttering the code with type annotations while keeping interface contracts strong (unlike in dynamic languages, you always know what a function expects as input and what it will emit as output).