Unit Structs

In Rust, a unit struct is a type of struct that doesn't have any fields. It is essentially a "marker" or "tag" type and is represented by an empty pair of curly braces (struct Name;).

Unit structs are particularly useful in scenarios where you need to define types without associated data. Here's an example:

pub struct Database;

Your Task

In this challenge, you'll implement a unit struct named Logger. The struct will serve as a type marker that enables certain logging functionality via a method log_message. You'll also implement a log_message function that prints a message to the console using the unit struct Logger as a marker. The goal is to familiarize yourself with unit structs and their usage as markers.

Requirements

Define a unit struct named Logger.
Implement a Logger::log_message method that:
- Takes a &str message as input.
- Prints the message to the console in the format: [LOG]: {message}.
Use the unit struct Logger to call this method.

Example Test

Logger::log_message("This is a test log.");
// Output: [LOG]: This is a test log.

Hints

Click here to reveal hints

Define the unit struct as pub struct Logger;.
Implement an associated function for the unit struct using the impl Logger block.
Use the println! macro to format and print the message.
Remember, unit structs do not require any fields and are defined with empty braces.

Editor not available on Mobile!

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

Solutions

Adrian Stanciu

stanciuadrian

5 hours ago

358.97ms

87.20kb

pub struct Logger;
impl Logger {
    pub fn log_message(message: &str) {
        println!("[LOG]: {message}");
    }
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

Adrian Stanciu

stanciuadrian

5 hours ago

368.20ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(message: &str) {
        println!("[LOG]: {message}");
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

sn00py-lays

7 hours ago

377.50ms

87.20kb

// Define a struct named `Logger`
pub struct Logger;
// Implement an associated function `log_message`
impl Logger {
    pub fn log_message(s: &str){
        println!("[LOG]: {}", s);
    }
}
// That accepts a `&str` and prints the output.
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

olivaresrafael

16 hours ago

346.73ms

87.13kb

pub struct Logger;
impl Logger {
    pub fn log_message(message : &str) -> ()  {
        println!("{}", message.to_string());
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

tommy759

a day ago

423.60ms

87.13kb

pub struct Logger;
impl Logger {
    pub fn log_message(message : &str) {
        println!("{}",message.to_string())
    }
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

Bastien VINH

bastienvinh

2 days ago

357.83ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(message: &str) {
        println!("{}", message)
    }    
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

yrd241

2 days ago

355.39ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger{
    pub fn log_message(s: &str){
        println!("s:{}",s);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

yqmt8708

2 days ago

399.88ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger{
    pub fn log_message(msg: &str) {
        println!("{}", msg);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

yqmt8708

2 days ago

427.52ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger{
    pub fn log_message(msg: &str) {
        println!("[LOG]: {}", msg);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Valtteri Äyräs

walterairs

2 days ago

368.28ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(msg: &str) {
        println!("{}", msg);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

ttenroK

2 days ago

388.81ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger {
}
impl Logger{
    pub fn log_message(msg : &str)
    {
        println!("{}", msg)
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

ychanghe

2 days ago

372.65ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger; 
impl Logger{
    pub fn log_message(strr: &str) -> (){
        println!("[LOG]:{}", strr)
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

JacobWarners

3 days ago

427.74ms

87.30kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
pub struct Logger;
impl Logger {
    pub fn log_message (message: &str) {
            println!("[LOG]: {message}")
}
    
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Omar Saber Talaat Abdelrahman

omar-s-ta

3 days ago

380.38ms

87.20kb

pub struct Logger;
impl Logger {
    pub fn log_message(msg: &str) {
        println!("[LOG]: {msg}")
    }
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

Anton

majesty-dump

3 days ago

394.17ms

87.25kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(message : &str) {
        println!("{}",message);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Bl4d3

DhruvJ2

4 days ago

457.55ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger{
    pub fn log_message(text: &str){
        println!("{}",text)
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Ari Karim

arikarim

4 days ago

399.00ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(message: &str) {
        println!("{}", message);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

/sam

samging

5 days ago

479.70ms

87.13kb

// Define a struct named `Logger`
pub struct Logger;
// Implement an associated function `log_message`
impl Logger {
    pub fn log_message(message: &str){
            let message = message.to_string();
            println!("{}",message);
    }
    
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

TESTNETSOL

5 days ago

383.24ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger{
    pub fn log_message(m:&str){
        println!("[LOG]: {m}")
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

2Madre

5 days ago

435.27ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger{
    pub fn log_message(log: &str){
        println!("{}", log);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Kishan

wdcs-kishansudani

5 days ago

473.54ms

87.20kb

pub struct Logger;
impl Logger {
    pub fn log_message(message: &str) {
        println!("[LOG]: {message}");
    }
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

Kishan

wdcs-kishansudani

5 days ago

356.95ms

87.20kb

pub struct Logger;
impl Logger {
    pub fn log_message(message: &str) {
        println!("[LOG]: {message}");
    }
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

daz

mintydevdaz

5 days ago

374.92ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(msg: &str) {
        println!("{}", msg)
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Dr. Frederik Lauber

FrederikLauber

6 days ago

445.46ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
// Example usage:
pub struct Logger;
impl Logger {
    pub fn log_message(msg: &str) {
        println!("[LOG]: {msg}")
    }
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

hidethere

7 days ago

387.35ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(s: &str) {
        println!("{}", s)
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

tommy759

7 days ago

405.86ms

87.13kb

pub struct Logger;
impl Logger {
    pub fn log_message(message : &str) {
        println!("{}",message.to_string())
    }
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

ibrahimomar9316

8 days ago

431.12ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger{
    pub fn log_message(message: &str){
        println!("{}" , message.to_string());
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

matthew-snyder

8 days ago

359.36ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(s: &str) {
       println!("[LOG]: {}", s);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Luigi

luigiistcrazy

8 days ago

400.19ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(string: &str) {
        println!("[LOG]: {}", string)
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Mark Cafazzo

capacitive

9 days ago

380.08ms

87.13kb

// Define a struct named `Logger`
pub struct Logger;
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
impl Logger {
    pub fn log_message(message: &str) -> Logger {
        println!("{}", message);
        return Logger {};
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Yummy-Yums

9 days ago

392.38ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(message: &str) {
        println!("{}", message)
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

A. A

An3005

9 days ago

355.28ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger{
    pub fn log_message(message: &str){
        println!("[LOG]: {}", message);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Fetisov Roman

Unstate

9 days ago

345.72ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(message: &str) -> () {
        println!("{}", message)
    }
} 
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Asrul Firdaus

AsrulF

9 days ago

416.44ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(input: &str) {
        println!("{input}");
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Joseph Kligel

josephkligel

11 days ago

452.33ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(message: &str){
        println!("[LOG]: {message}");
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

YE Qingtian

YE-Qingtian

11 days ago

418.34ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger {
}
impl Logger {
    pub fn log_message(message: &str) {
        println!("[LOG]: {}", message);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

reborn3d

11 days ago

364.48ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger{
    pub fn log_message(msg :&str){
        println!("{0}",msg);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

SubZ69

12 days ago

381.48ms

87.20kb

pub struct Logger;
impl Logger {
    pub fn log_message(m: &str) {
        println!("[LOG]: {m}");
    }
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

ex0x21e

13 days ago

339.21ms

87.20kb

pub struct Logger;
// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
impl Logger{
    pub fn log_message(message: &str) -> (){
        println!("[LOG]: {message}")
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Kangyan-Zhou

13 days ago

405.99ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(message: &str) {
        println!("{}", message);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Tamir Azaouag

Tamir-Azaouag

13 days ago

418.06ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger{
    pub fn log_message(message: &str){
        println!("[LOG]: {message}")
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Alan Castro

acsoliz

13 days ago

356.05ms

87.20kb

pub struct Logger;
// Implement the associated function `log_message`
impl Logger {
    pub fn log_message(message: &str) {
        println!("[LOG]: {}", message);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

jfloresremar

15 days ago

390.50ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger {}
impl Logger {
    pub fn log_message(message: &str) {
        println!("[LOG]: {message}");
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Aziz Bouali

saaya-code

15 days ago

356.74ms

87.13kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger{
    pub fn log_message(txt: &str){
        println!("{}", txt);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

K S

ks10825n

15 days ago

342.37ms

87.20kb

// Define a struct named `Logger`
pub struct Logger;
// Implement an associated function `log_message`
impl Logger {
    pub fn log_message(message: &str) {
        println!("[LOG]: {}", message);
    }
}
// That accepts a `&str` and prints the output.
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

McBandaska

16 days ago

336.24ms

87.20kb

pub struct Logger;
impl Logger{
    pub fn log_message(message: &str){
        println!("[LOG]: {}", message);
    }
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

Navneet Sachan

manbearpig1996

16 days ago

389.33ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
// Example usage:
pub struct Logger {}
impl Logger {
    pub fn log_message(message : &str) {
        println!("[LOG]: {}", message)
    }
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

Mussiee

16 days ago

371.77ms

87.20kb

// Define a struct named `Logger`
pub struct Logger; 
// Implement an associated function `log_message`
impl Logger { 
   pub fn log_message(mes: &str) { 
        println!("[LOG]: {mes}"); 
   } 
}
// That accepts a `&str` and prints the output.
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Istvan Basa

pottom

16 days ago

349.36ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(message: &str) -> Self {
        println!("[LOG]: {}", message);
        return Self
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Huynh Thien Loc

samual420

16 days ago

332.70ms

87.20kb

// Define a struct named `Logger`
// Implement an associated function `log_message`
// That accepts a `&str` and prints the output.
pub struct Logger;
impl Logger {
    pub fn log_message(message: &str) -> Logger{
        println!("[LOG]: {}",message);
        return Logger
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}