The AsRef Trait

Working with strings is a common requirement in real-world applications. Sometimes, you want a function that can take either a String or a &str as input without needing separate implementations. Rust's AsRef trait provides a simple way to borrow data as a reference in a generic manner, enabling functions to work with various types that can be represented as a reference to a common type.

The AsRef trait is a powerful standard library trait used for cheap conversions to a reference of another type. For example, it can be used to create a function that works with both owned (String) and borrowed (&str) string types. This approach is lightweight and avoids unnecessary allocations.

Your Task

Implement a function print_message that accepts any type that implements the AsRef<str> trait. This function should:

Accept a single argument of a generic type that implements AsRef<str>.
Borrow the input as a string slice (&str) and print it to the console using println!.

Hints

Click here to reveal hints

The AsRef trait provides a .as_ref() method to borrow a reference.
Both String and &str implement AsRef<str>, so they can be used interchangeably with this trait.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Jordan

Jordan-Haidee

4 hours ago

377.33ms

100.64kb

pub fn print_message<T>(s : T)
where
    T : AsRef<str> + std::fmt::Display
{
    println!("{}", &s);
} // Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Jun Huang

leemars

a day ago

369.98ms

100.64kb

pub fn print_message<T: AsRef<str> + std::fmt::Display>(msg: T) {
    println!("{}", msg);
} // Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Kyle Diaz

kylediaz

2 days ago

351.46ms

100.64kb

pub fn print_message<T: AsRef<str>>(v: T) {
    println!("{}", v.as_ref());
} 
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Kenneth Love

kennethlove

3 days ago

355.48ms

100.64kb

pub fn print_message<T: AsRef<str>>(input: T) {
    println!("{}", input.as_ref())
} // Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Viktor Merkurev

fennr

3 days ago

359.73ms

100.64kb

pub fn print_message<T>(message: T) -> ()
where T: AsRef<str> {
    println!("{}", message.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

alemack17

5 days ago

350.44ms

100.64kb

pub fn print_message<T: AsRef<str>>(message: T){
    println!("{}",message.as_ref());
} // Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Marco-Normal

5 days ago

371.11ms

100.64kb

pub fn print_message<T: AsRef<str>>(it: T) {
    println!("{}", it.as_ref())
} // Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

ludovicknecht

5 days ago

368.08ms

100.64kb

pub fn print_message<T: AsRef<str>>(message: T) {
    println!("{}", message.as_ref())
}

Denis SOURON

Brack0

5 days ago

346.81ms

100.64kb

pub fn print_message<T>(message: T)
where
    T: AsRef<str>,
{
    println!("{}", message.as_ref());
}

Romain Grimau

Herrgrim0

6 days ago

441.32ms

100.64kb

pub fn print_message<T: AsRef<str> + std::fmt::Display>(val: T) {
    println!("{}", &val);
} // Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Whisper_icoma

1378046967

7 days ago

362.08ms

100.64kb

pub fn print_message<T>(input: T)
where
    T: AsRef<str>,
{
    println!("{}", input.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

RiyadDz22

7 days ago

344.73ms

100.64kb

pub fn print_message<T>(input: T)
where
    T: AsRef<str>,
{
    println!("{}", input.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

kosay

sarub0b0

7 days ago

370.19ms

100.64kb

pub fn print_message<T: AsRef<str>>(msg: T) {
    println!("{}", msg.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

automata-studio

8 days ago

355.18ms

100.64kb

pub fn print_message<T>(message: T)
where T: AsRef<str> {
    println!("{}", message.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

rawar089

9 days ago

405.25ms

100.64kb

pub fn print_message<T: AsRef<str> >(msg: T) {
    println!("{}",msg.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Algorab

9 days ago

362.67ms

100.64kb

pub fn print_message<T>(s: T)
where T: ::std::fmt::Display + AsRef<str>
{
    println!("{}", s);
} // Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Nikita Smirnov

Nismirno

9 days ago

348.14ms

100.64kb

pub fn print_message<T>(input: T)
where
    T: AsRef<str>,
{
    println!("{}", input.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

delxs

9 days ago

356.78ms

100.64kb

pub fn print_message<T: AsRef<str>>(strings: T) {
    println!("{}", strings.as_ref())
}// Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

iamforgettable

9 days ago

428.97ms

100.64kb

pub fn print_message<T>(greeting: T)
where T: AsRef<str> + std::fmt::Display {
    println!("{}", &greeting);
} // Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Elliott Draper

ejdraper

10 days ago

370.99ms

100.64kb

use std::fmt::Display;
pub fn print_message<T: Display + AsRef<str>>(s: T) {
    println!("{}", &s);
} // Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Justin Maillet

justy777

11 days ago

342.09ms

100.64kb

pub fn print_message<T: AsRef<str>>(message: T) {
    println!("{}", message.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Oebelus

oebelus

12 days ago

339.98ms

100.64kb

pub fn print_message<T>(x: T)
where T: AsRef<str> {
    println!("{}", x.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Jim Lawton

jimlawton

12 days ago

365.29ms

100.64kb

pub fn print_message<T: AsRef<str>>(message: T) {
    println!("{}", message.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Stefan Roas

sroas

12 days ago

359.13ms

100.64kb

pub fn print_message<T: AsRef<str>>(msg: T) {
    println!("{}", msg.as_ref());
} // Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Shafer Hess

shafer-hess

13 days ago

360.21ms

100.64kb

pub fn print_message<T: AsRef<str>>(msg: T) {
    println!("{}", msg.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Jonathan Voss

jvoss

14 days ago

386.84ms

100.64kb

pub fn print_message<T: AsRef<str>>(string: T) { // Finish the function
    println!("{}", string.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

TaiPoole

15 days ago

350.10ms

100.64kb

pub fn print_message<T>(msg: T) where T: AsRef<str>{
    println!("{}", msg.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

dawwestk

15 days ago

357.68ms

100.64kb

pub fn print_message<T>(msg: T)
where
    T: AsRef<str>
{
    println!("{}", msg.as_ref());
}// Finish the function
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

Christopher Nielson

c-nielson

17 days ago

362.86ms

100.64kb

pub fn print_message<T: AsRef<str>> (message: T) {
    println!("{}", message.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}

PangoSea

kapaseker

18 days ago

365.57ms

100.64kb

pub fn print_message<T: AsRef<str>>(a: T) {
    println!("{}", a.as_ref());
}
// Example usage
pub fn main() {
    // Example 1: Using a &str
    print_message("Hello, world!");
    // Example 2: Using a String
    let greeting = String::from("Welcome to Rust!");
    print_message(greeting);
}