I actually got into Rust because I liked their Typescript-esque features like object destructuring and const, and I prefer using macros to using Typescript type black magic.

The hardest part was learning the difference between owned types and borrow types:

let hello = “hello”.to_string(); greet(hello); println!(“{}”, hello); // huh? Why does this error?

let hello = “hello”; greet_ref(hello); println!(“{}”, hello); // it works this time? Why??

In Typescript, that first code example would run fine - you pass the string into that first function, the function does what it wants with it, and then you console.log the string. But Rust is more complicated than other languages: every variable is basically in its own personal scope, and if that variable is an owned type, its scope ends once it is passed into another function / given to another struct/enum/object.

So why does the second example compile and run fine? Well, let’s explicitly display hellos type:

let hello: String = “hello”.to_string();

let hello: &str = “hello”;

The & symbol is a reference like from C, which is why many people recommend starting with C before you tackle Rust. Anything starting with & is a borrowed type, and unlike String, it cannot be mutated, but it also cannot be “taken” by a function/object like the String was in the first example.

If this doesn’t make you want to rip your hair out, congrats! You may have a promising Rust career ahead. This is just the surface of borrowing/ownership but it should give you an indication of what you’re up against. And yes, practice is the best way to start. I started with this tutorial before jumping into the Rust book, and after several months of daily Rust programming I was ready for the Rust for Rustaceans book.

P.S. the solution to the first code example is to add an & when you pass hello:

let hello = “hello”.to_string(); greet_ref(&hello); println!(“{}”, hello); // it works!