Defining and Instantiating Structs

Structs are similar to tuples, discussed in “The Tuple Type” section, in that both hold multiple related values. Like tuples, the pieces of a struct can be different types. Unlike with tuples, in a struct you’ll name each piece of data so it’s clear what the values mean. Adding these names means that structs are more flexible than tuples: you don’t have to rely on the order of the data to specify or access the values of an instance.

To define a struct, we enter the keyword struct and name the entire struct. A struct’s name should describe the significance of the pieces of data being grouped together. Then, inside curly brackets, we define the names and types of the pieces of data, which we call fields. For example, Listing 5-1 shows a struct that stores information about a user account.

  1. struct User {
  2. active: bool,
  3. username: String,
  4. email: String,
  5. sign_in_count: u64,
  6. }
  7. fn main() {}

Listing 5-1: A User struct definition

To use a struct after we’ve defined it, we create an instance of that struct by specifying concrete values for each of the fields. We create an instance by stating the name of the struct and then add curly brackets containing key: value pairs, where the keys are the names of the fields and the values are the data we want to store in those fields. We don’t have to specify the fields in the same order in which we declared them in the struct. In other words, the struct definition is like a general template for the type, and instances fill in that template with particular data to create values of the type. For example, we can declare a particular user as shown in Listing 5-2.

  1. struct User {
  2. active: bool,
  3. username: String,
  4. email: String,
  5. sign_in_count: u64,
  6. }
  7. fn main() {
  8. let user1 = User {
  9. email: String::from("someone@example.com"),
  10. username: String::from("someusername123"),
  11. active: true,
  12. sign_in_count: 1,
  13. };
  14. }

Listing 5-2: Creating an instance of the User struct

To get a specific value from a struct, we use dot notation. For example, to access this user’s email address, we use user1.email. If the instance is mutable, we can change a value by using the dot notation and assigning into a particular field. Listing 5-3 shows how to change the value in the email field of a mutable User instance.

  1. struct User {
  2. active: bool,
  3. username: String,
  4. email: String,
  5. sign_in_count: u64,
  6. }
  7. fn main() {
  8. let mut user1 = User {
  9. email: String::from("someone@example.com"),
  10. username: String::from("someusername123"),
  11. active: true,
  12. sign_in_count: 1,
  13. };
  14. user1.email = String::from("anotheremail@example.com");
  15. }

Listing 5-3: Changing the value in the email field of a User instance

Note that the entire instance must be mutable; Rust doesn’t allow us to mark only certain fields as mutable. As with any expression, we can construct a new instance of the struct as the last expression in the function body to implicitly return that new instance.

Listing 5-4 shows a build_user function that returns a User instance with the given email and username. The active field gets the value of true, and the sign_in_count gets a value of 1.

  1. struct User {
  2. active: bool,
  3. username: String,
  4. email: String,
  5. sign_in_count: u64,
  6. }
  7. fn build_user(email: String, username: String) -> User {
  8. User {
  9. email: email,
  10. username: username,
  11. active: true,
  12. sign_in_count: 1,
  13. }
  14. }
  15. fn main() {
  16. let user1 = build_user(
  17. String::from("someone@example.com"),
  18. String::from("someusername123"),
  19. );
  20. }

Listing 5-4: A build_user function that takes an email and username and returns a User instance

It makes sense to name the function parameters with the same name as the struct fields, but having to repeat the email and username field names and variables is a bit tedious. If the struct had more fields, repeating each name would get even more annoying. Luckily, there’s a convenient shorthand!

Using the Field Init Shorthand

Because the parameter names and the struct field names are exactly the same in Listing 5-4, we can use the field init shorthand syntax to rewrite build_user so that it behaves exactly the same but doesn’t have the repetition of email and username, as shown in Listing 5-5.

  1. struct User {
  2. active: bool,
  3. username: String,
  4. email: String,
  5. sign_in_count: u64,
  6. }
  7. fn build_user(email: String, username: String) -> User {
  8. User {
  9. email,
  10. username,
  11. active: true,
  12. sign_in_count: 1,
  13. }
  14. }
  15. fn main() {
  16. let user1 = build_user(
  17. String::from("someone@example.com"),
  18. String::from("someusername123"),
  19. );
  20. }

Listing 5-5: A build_user function that uses field init shorthand because the email and username parameters have the same name as struct fields

Here, we’re creating a new instance of the User struct, which has a field named email. We want to set the email field’s value to the value in the email parameter of the build_user function. Because the email field and the email parameter have the same name, we only need to write email rather than email: email.

Creating Instances From Other Instances With Struct Update Syntax

It’s often useful to create a new instance of a struct that includes most of the values from another instance, but changes some. You can do this using struct update syntax.

First, in Listing 5-6 we show how to create a new User instance in user2 regularly, without the update syntax. We set a new value for email but otherwise use the same values from user1 that we created in Listing 5-2.

  1. struct User {
  2. active: bool,
  3. username: String,
  4. email: String,
  5. sign_in_count: u64,
  6. }
  7. fn main() {
  8. // --snip--
  9. let user1 = User {
  10. email: String::from("someone@example.com"),
  11. username: String::from("someusername123"),
  12. active: true,
  13. sign_in_count: 1,
  14. };
  15. let user2 = User {
  16. active: user1.active,
  17. username: user1.username,
  18. email: String::from("another@example.com"),
  19. sign_in_count: user1.sign_in_count,
  20. };
  21. }

Listing 5-6: Creating a new User instance using one of the values from user1

Using struct update syntax, we can achieve the same effect with less code, as shown in Listing 5-7. The syntax .. specifies that the remaining fields not explicitly set should have the same value as the fields in the given instance.

  1. struct User {
  2. active: bool,
  3. username: String,
  4. email: String,
  5. sign_in_count: u64,
  6. }
  7. fn main() {
  8. // --snip--
  9. let user1 = User {
  10. email: String::from("someone@example.com"),
  11. username: String::from("someusername123"),
  12. active: true,
  13. sign_in_count: 1,
  14. };
  15. let user2 = User {
  16. email: String::from("another@example.com"),
  17. ..user1
  18. };
  19. }

Listing 5-7: Using struct update syntax to set a new email value for a User instance but use the rest of the values from user1

The code in Listing 5-7 also creates an instance in user2 that has a different value for email but has the same values for the username, active, and sign_in_count fields from user1. The ..user1 must come last to specify that any remaining fields should get their values from the corresponding fields in user1, but we can choose to specify values for as many fields as we want in any order, regardless of the order of the fields in the struct’s definition.

Note that the struct update syntax uses = like an assignment; this is because it moves the data, just as we saw in the “Ways Variables and Data Interact: Move” section. In this example, we can no longer use user1 after creating user2 because the String in the username field of user1 was moved into user2. If we had given user2 new String values for both email and username, and thus only used the active and sign_in_count values from user1, then user1 would still be valid after creating user2. The types of active and sign_in_count are types that implement the Copy trait, so the behavior we discussed in the “Stack-Only Data: Copy” section would apply.

Using Tuple Structs without Named Fields to Create Different Types

Rust also supports structs that look similar to tuples, called tuple structs. Tuple structs have the added meaning the struct name provides but don’t have names associated with their fields; rather, they just have the types of the fields. Tuple structs are useful when you want to give the whole tuple a name and make the tuple a different type from other tuples, and when naming each field as in a regular struct would be verbose or redundant.

To define a tuple struct, start with the struct keyword and the struct name followed by the types in the tuple. For example, here we define and use two tuple structs named Color and Point:

  1. struct Color(i32, i32, i32);
  2. struct Point(i32, i32, i32);
  3. fn main() {
  4. let black = Color(0, 0, 0);
  5. let origin = Point(0, 0, 0);
  6. }

Note that the black and origin values are different types, because they’re instances of different tuple structs. Each struct you define is its own type, even though the fields within the struct might have the same types. For example, a function that takes a parameter of type Color cannot take a Point as an argument, even though both types are made up of three i32 values. Otherwise, tuple struct instances are similar to tuples in that you can destructure them into their individual pieces, and you can use a . followed by the index to access an individual value.

Unit-Like Structs Without Any Fields

You can also define structs that don’t have any fields! These are called unit-like structs because they behave similarly to (), the unit type that we mentioned in “The Tuple Type” section. Unit-like structs can be useful when you need to implement a trait on some type but don’t have any data that you want to store in the type itself. We’ll discuss traits in Chapter 10. Here’s an example of declaring and instantiating a unit struct named AlwaysEqual:

  1. struct AlwaysEqual;
  2. fn main() {
  3. let subject = AlwaysEqual;
  4. }

To define AlwaysEqual, we use the struct keyword, the name we want, then a semicolon. No need for curly brackets or parentheses! Then we can get an instance of AlwaysEqual in the subject variable in a similar way: using the name we defined, without any curly brackets or parentheses. Imagine that later we’ll implement behavior for this type such that every instance of AlwaysEqual is always equal to every instance of any other type, perhaps to have a known result for testing purposes. We wouldn’t need any data to implement that behavior! You’ll see in Chapter 10 how to define traits and implement them on any type, including unit-like structs.

Ownership of Struct Data

In the User struct definition in Listing 5-1, we used the owned String type rather than the &str string slice type. This is a deliberate choice because we want each instance of this struct to own all of its data and for that data to be valid for as long as the entire struct is valid.

It’s also possible for structs to store references to data owned by something else, but to do so requires the use of lifetimes, a Rust feature that we’ll discuss in Chapter 10. Lifetimes ensure that the data referenced by a struct is valid for as long as the struct is. Let’s say you try to store a reference in a struct without specifying lifetimes, like the following; this won’t work:

Filename: src/main.rs

  1. struct User {
  2. active: bool,
  3. username: &str,
  4. email: &str,
  5. sign_in_count: u64,
  6. }
  7. fn main() {
  8. let user1 = User {
  9. email: "someone@example.com",
  10. username: "someusername123",
  11. active: true,
  12. sign_in_count: 1,
  13. };
  14. }

The compiler will complain that it needs lifetime specifiers:

  1. $ cargo run
  2. Compiling structs v0.1.0 (file:///projects/structs)
  3. error[E0106]: missing lifetime specifier
  4. —> src/main.rs:3:15
  5. |
  6. 3 | username: &str,
  7. | ^ expected named lifetime parameter
  8. |
  9. help: consider introducing a named lifetime parameter
  10. |
  11. 1 ~ struct User<'a> {
  12. 2 | active: bool,
  13. 3 ~ username: &'a str,
  14. |
  15. error[E0106]: missing lifetime specifier
  16. —> src/main.rs:4:12
  17. |
  18. 4 | email: &str,
  19. | ^ expected named lifetime parameter
  20. |
  21. help: consider introducing a named lifetime parameter
  22. |
  23. 1 ~ struct User<'a> {
  24. 2 | active: bool,
  25. 3 | username: &str,
  26. 4 ~ email: &'a str,
  27. |
  28. For more information about this error, try rustc --explain E0106.
  29. error: could not compile structs due to 2 previous errors

In Chapter 10, we’ll discuss how to fix these errors so you can store references in structs, but for now, we’ll fix errors like these using owned types like String instead of references like &str.