#Rust πŸ¦€ – 🧡 String Interpolation in Rust (as usual, super fun πŸ˜„)

Hi !

Working with string is always a nice topic to learn. It’s nice to understand how a specific language process strings, sometimes small changes can have big performance improvements !

String Interpolation

So let’s start (via Wikipedia) with some basic concepts.

In computer programming, string interpolation (or variable interpolation, variable substitution, or variable expansion) is the process of evaluating a string literal containing one or more placeholders, yielding a result in which the placeholders are replaced with their corresponding values. It is a form of simple template processing[1] or, in formal terms, a form of quasi-quotation (or logic substitution interpretation). The placeholder may be a variable name, or in some languages an arbitrary expression, in either case evaluated in the current context.

String interpolation is an alternative to building string via concatenation, which requires repeated quoting and unquoting;[2] or substituting into a printf format string, where the variable is far from where it is used. Compare:

String Interpolation – Wikipedia
apples = 4
print("I have ${apples} apples.") # string interpolation
print("I have " + apples + " apples.") # string concatenation
print("I have %s apples.", apples) # format string

String Interpolation in Rust

Rust does not have general string interpolation, but provides similar functionality via macros. Rust provides formatting via the std::fmt module, which is interfaced with through various macros such as format!, write!, and print!.

The hello world example may look like this one:

running the code
fn main() {
    println!("Hello {}!", "world");
}
output 
Hello world!

These macros are converted into Rust source code at compile-time, whereby each argument interacts with a formatter. The formatter supports positional parameters, named parameters, argument types, defining various formatting traits, and capturing identifiers from the environment.

We can also work with implicit named arguments. I like this option, the code is easier to read.

/*
Copyright (c) 2023
Author : Bruno Capuano
Create Time : 2023 January
Change Log :
– Working with strings with implicit named arguments
The MIT License (MIT)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
fn main() {
let (petname, petage) = ("ACE", 1);
println!("{petname} the pet is {petage} years old.");
// Expected output: ACE the pet is 1 years old.
}

However, if we work with structs or tuples, we can’t use this option because field access isn’t supported.

Let’s take a look at the following sample.

struct Pet { name: String, age: u8}

fn main() {
    let pet_ace = Pet { name: String::from("ACE"), age: 1 };
    println!("{pet_ace.name} the pet is {pet_ace.age} years old.");
    // Expected output: ACE the pet is 1 years old.
}

And this is the output, with super cool error.

error: invalid format string: field access isn't supported
  --> src\main.rs:32:16
   |
32 |     println!("{pet_ace.name} the pet is {pet_ace.age} years old.");
   |                ^^^^^^^^^^^^ not supported in format string
   |
help: consider using a positional formatting argument instead
   |
32 |     println!("{0} the pet is {pet_ace.age} years old.", pet_ace.name);
   |                ~                                      ++++++++++++++

The full source code for the previous scenario is available here.

/*
Copyright (c) 2023
Author : Bruno Capuano
Create Time : 2023 January
Change Log :
– Working with strings with strucs and named arguments
The MIT License (MIT)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
struct Pet {
name: String,
age: u8,
}
fn main() {
let pet_ace = Pet {
name: String::from("ACE"),
age: 1,
};
// println!("{pet_ace.name} the pet is {pet_ace.age} years old.");
// Trigger this error:
// println!("{pet_ace.name} the pet is {pet_ace.age} years old.");
// ^^^^^^^^^^^^ not supported in format string
println!("{} the pet is {} years old.", pet_ace.name, pet_ace.age);
// Expected output: ACE the pet is 1 years old.
}

At this moment, I think I’ll read more about the way Rust works with Strings. Mostly in the official Rust Documentation for Strings.

Happy coding!

Greetings

El Bruno

More posts in my blog ElBruno.com.


Leave a comment

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

%d bloggers like this: