Let’s learn about Rust strings. As in plural. There are essentially two types. Um, what? You can’t be serious? Well, kinda.

Is this going to be one of those examples that demonstrates why Rust is hard to learn? No, not really. But, as simple as Strings are in other languages, they are a great gateway into the Rust ownership model, stack vs heap, etc… Before we get ahead of ourselves, let’s see some simple examples compared to Ruby.

In Ruby, we can use Strings as values for variables and constants. We’re going to use our Ruby project from the Getting Started post.

You can see we already use a String in the `puts` statement. The code “hello world” defines a String value. Let’s add some more examples.

If you run this file via `ruby lib/my_project_ruby.rb` from the project root, you will see:

If you are familiar with Ruby all of this should be familiar. We defined a Constant with a String value. Next we defined a variable called `substring` and used a method on a String to define another String value. Lastly, we used the existing `puts` statement and rather than printing out the String value, we printed out the class of the value which of course is String. Defining Strings in Ruby is pretty straightforward. You can use double or single quotes.

Let’s look at the equivalent in Rust. Again, we’ll reuse our Rust project from the [Getting Started] post.

Here we go! This is where we get into there being two String types in Rust. See how the constant is defined with a type of `&str`. This is the String literal in Rust. It is most commonly referred to as a string slice. And in its **borrowed** form. You may already be thinking that Rust Strings are a lot more complex than in a language like Ruby. Tis true. Let’s unpack this and get a good understanding.

Strings can be defined in two ways in Rust.

`str` is defined here: [https://doc.rust-lang.org/std/str/index.html].

`String` is defined here: [https://doc.rust-lang.org/std/string/struct.String.html]

Ok, why are there two String types? This is where we have to get into how Rust manages memory and performs so well. Rust manages memory using a Stack and a Heap. If you want a brief but concise overview, I suggest the Rust book. In the Ownership section there is a great break out section that describes the Stack vs the Heap.

Notice in the comments, I wrote `aka not growable` and `aka a growable string`. Growable in this sense means, we know the exact value at the time we define the value, or we don’t know the entire value at the time, or suspect it will change. In the first statement where we define `hello_world` using a &str value, we know the entire value and it is not going to change. Based on this information, Rust can place this variable and its value on the Stack. It’s concrete and therefore we can be precise about the amount of memory we need. This makes it fast to retrieve. The Rust book explains: “In the case of a string literal, we know the contents at compile time, so the text is hardcoded directly into the final executable. This is why string literals are fast and efficient.”

Let’s see what happens when we try to grow it:

When we run this with `cargo run`, we receiving the following error:

`push_str` is a method used to concatenate a String. Notice it doesn’t exist on &str. That is our first clue that we should think of &str values as not able to be changed.

In the second `let` we use `String::from` to define the value. Image we are collecting user input from a form. We don’t know the value the user would provide, so we take that input and use it to define a String. Because we don’t know the explicit and complete value, we use a String type and Rust stores this value on the Heap. This gives us a slot in memory that will be accommodating for various lengths of strings (with defined bounds). If we’re accepting user input, we may not know the number of characters they are going to enter, so we need variable space. Say something between 0 and 64 characters for example. Rust’s String struct contains an address, length and capacity. Capacity being the maxed allowed size.

Let’s see what happens when we try to grow that value:

This compiles and the result is: `Hello World!`

Notice we used `mut` to make the variable mutable, but the point isn’t about mutatability. We are talking about known values. Maybe we should think of them as hard coded vs dynamic values. In Ruby, `NAME = "foo".freeze` would be a &str because the value would be known, essentially hardcoded, should there be a compile step. Obviously, the same classes and objects don’t exist in both Ruby and Rust, so It’s not apples to apples. We’re simply using them to illustrate the point.

I was going to cover borrowing now since I mentioned it before, but it’s a topic all its own. For simple terms, let’s say borrowing means you reference values (and memory slots) rather than copying the value for a specific scope. We’ll cover it in a lot more detail in a future post.

So let’s stick to strings. Let’s complete this post with a look at how to do common things regardless of language. First a few common examples in Rust.

And now the equivalent in Ruby:

That gives a basic overview of Strings in Rust compared to Ruby. In the next post, we’ll get into the various other common objects related to numbers.