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

Pranav Garg

PranavGarg01

8 hours ago

345.72ms

100.64kb

pub fn print_message<T : AsRef<str>>(v : T)  {// Finish the function 
    let x : &str = v.as_ref();
    println!("{}",x);
}
// 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);
}

amaneru

7ma8no9

a day ago

396.10ms

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);
}

Sandeep chauhan

ryzen-xp

a day ago

421.04ms

100.64kb

pub fn print_message < T: AsRef<str>>  ( s : T){
    println!("{}" , s.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);
}

Sandeep chauhan

ryzen-xp

a day ago

359.91ms

100.64kb

pub fn print_message < T: AsRef<str>>  ( s : T){
    println!("{}" , s.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);
}

TiagONTOP

2 days ago

359.38ms

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);
}

Muhammad-Dennis

3 days ago

376.43ms

100.64kb

pub fn print_message<A>(s: A) 
where
    A: AsRef<str>
{   
    let the_ref = s.as_ref();
    println!("{}", the_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);
}

AKA.MoneyTaker

M4Bo2

4 days ago

392.79ms

100.64kb

pub fn print_message<T: AsRef<str>>(message: T) {
    // Borrow the input as a string slice (&str) and print it
    println!("{}", message.as_ref());
} // Finish the functionImplement 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!
// 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);
}

Simon Noetzlin

sainoe

4 days ago

378.67ms

100.64kb

pub fn print_message<T:AsRef<str>>(x:T){
  println!("{}", x.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);
}

Anıl Şenay

anilsenay

6 days ago

382.67ms

100.64kb

pub fn print_message<T: AsRef<str>>(s: T) {
    println!("{}",s.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);
}

Suraj Vijayan

its-me-sv

6 days ago

387.02ms

100.64kb

pub fn print_message<T: AsRef<str>>(s: T) { // Finish the function
    println!("{}", s.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);
}

Dyaa Adel

dyaa-adel

7 days ago

365.84ms

100.64kb

pub fn print_message<T : AsRef<str> + std::fmt::Display >(input : T) {
    println!("{}", input);
}
// 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);
}

Lê Minh Quân

aleister1102

7 days ago

377.04ms

100.64kb

pub fn print_message<T: AsRef<str> + std::fmt::Display>(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);
}

Guilherme Cesário Strachan

strachan

8 days ago

338.73ms

100.64kb

pub fn print_message<T: AsRef<str>>(arg: T) {
    println!("{}", arg.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);
}

Yi Hao

leongyihao

8 days ago

353.27ms

100.64kb

use std::fmt::Display;
pub fn print_message<T: AsRef<str> + Display>(str : T) {
	println!("{}", str);
}
// 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);
}

tzmijewski

8 days ago

373.16ms

100.64kb

pub fn print_message<T: AsRef<str> + std::fmt::Display>(message: T) {// Finish the function 
    println!("{}", message);
}
// 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);
}

manuelmj

8 days ago

340.34ms

100.64kb

use std::fmt::Display; 
pub fn print_message<T>(value: T )
where T: AsRef<str> + Display{
    println!("{value}");
}
// 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);
}

Kentaro Abe

abekem

9 days ago

371.20ms

100.64kb

pub fn print_message<T: AsRef<str>>(s: T) {
    println!("{}", s.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);
}

Ayushman Rathore

Spartan09

9 days ago

362.53ms

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);
}

norabbito

9 days ago

353.59ms

100.64kb

pub fn print_message<T: AsRef<str>>(s: T) {
    // Finish the function
    println!("{}", s.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);
}

Jordan

Jordan-Haidee

12 days 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

13 days 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

14 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

15 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

15 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

17 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

17 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

17 days ago

368.08ms

100.64kb

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

Denis SOURON

Brack0

17 days ago

346.81ms

100.64kb

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

Romain Grimau

Herrgrim0

18 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

19 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

19 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

19 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

20 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

21 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

21 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

21 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

21 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

22 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

22 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

23 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

24 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

24 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

24 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

25 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

a month 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

a month 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

a month 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

a month 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

a month 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);
}