10 Mar 24

Rust strings compared to Ruby
Originally posted on Medium

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.

# lib/my_project_ruby.rbmodule MyProjectRuby class Error < StandardError; end # Your code goes here... puts "hello world"end

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.

# lib/my_project_ruby.rbmodule MyProjectRuby class Error < StandardError; end NAME = "foo" puts NAME.class # => String substring = "this is a string".split(" ").last puts substring.class # => String puts "hello world".classend

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.

// src/main.rsconst NAME: &str = "foo";fn main() { println!("value of constant is {}", NAME); println!("Hello, world!");}

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.

// this is a string slice type (aka &str) (aka not growable)let hello_world = "Hello, World";// this is a String type (aka a growable string)let hello_world = String::from("Hello, world!");

`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:

// src/main.rsconst NAME: &str = "foo";fn main() { println!("value of constant is {}", NAME); let hello_world = "Hello World"; hello_world.push_str("! May I borrow you?"); println!("{}", hello_world);}

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

error[E0599]: no method named `push_str` found for reference `&str` in the current scope --> src/main.rs:8:17 |8 | hello_world.push_str("! May I borrow you?"); | ^^^^^^^^ method not found in `&str`

`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:

// src/main.rsconst NAME: &str = "foo";fn main() { println!("value of constant is {}", NAME); let mut hello_world = String::from("Hello World"); hello_world.push_str("!"); // add the exclamation println!("{}", hello_world);}

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.

// src/main.rsfn main() { # basic assignment let hello_world = "Hello World"; // print a string println!("{}", hello_world); // concatenate a string let mut name = String::from("Steve"); name.push_str(" Jobs"); println!("name: {}", &name); // determine the length of a string (answer: 3) let len = "foo".len(); println!("len: {}", &len); // determine the index of a substring let index: Vec<_> = "foobar".match_indices("bar").collect(); println!("index: {}", &index[0].0); // trim newlines and spaces let trim = " \nfoo \n ".trim(); println!("trimmed: {}", trim); // debug/display trait let debug_str = "this is a &str"; dbg!(debug_str); let debug_string = String::from("this is a String"); dbg!(debug_string);}

And now the equivalent in Ruby:

module MyProjectRuby class Error < StandardError; end # basic assignment hello_world = "hello world!" # print a string puts hello_world # concatenate a string name = "Steve"; name += " Jobs"; puts name # determine the length of a string (answer: 3) len = "foo".size puts "len: #{len}" # determine the index of a substring index = "foobar".index("bar") puts "index: #{index}" # trim newlines and spaces trim = " \nfoo \n ".strip(); puts "trimmed: #{trim}" # debug/display trait debug_str = "this is a string"; puts debug_str.inspectend

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.