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

Esteban Pérez

lep511

an hour ago

360.77ms

87.20kb

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

Madhankumar Anandan

amkumar072

4 hours ago

350.63ms

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

Elizabeth Doughty

Thymelizabeth

6 hours ago

400.36ms

87.20kb

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

kustrun

7 hours ago

365.43ms

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

Icarus

IcarusxB

a day ago

366.60ms

87.20kb

pub struct Logger;
impl Logger {
pub fn log_message(input: &str) ->() {
   let string = input.to_string();
    print!("[LOG]: {}", string)
}
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

medzernik

a day ago

380.97ms

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

G Towers

gtowers-dukosi

a day ago

341.60ms

87.20kb

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

Lucas Deprit

lucasdeprit

a day ago

361.22ms

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

Facundo Hernandez

facuhernandez99

2 days ago

339.74ms

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(input: &str){
        println!("[LOG]: {}",input);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Icarus

IcarusxB

2 days ago

344.97ms

87.20kb

pub struct Logger;
impl Logger {
pub fn log_message(input: &str) ->() {
   let string = input.to_string();
    print!("[LOG]: {}", string)
}
}
pub fn main() {
    Logger::log_message("Hello, World!");
}

vojta stefan

vojtastefan

2 days ago

374.74ms

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

JackY

Scorpio24

2 days ago

449.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(massage: &str){
        println!("{}", massage);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Hung Dinh

nhdinh

3 days ago

398.82ms

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

amaneru

7ma8no9

3 days ago

374.74ms

87.30kb

// 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!("{}", format!("[LOG]: {}", message));
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Lauri Sarap

LauriSarap

4 days ago

363.90ms

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

Heatiche Mix

HeaticheTakachi

4 days ago

377.66ms

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

Pranav Garg

PranavGarg01

4 days ago

341.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(msg : &str) {
        println!("[LOG]: {}", msg);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Léa Narzis

lean-apple

4 days ago

376.32ms

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

happines

rhithesh

5 days ago

396.02ms

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

Artyom Chebotarev

Derik117

5 days ago

361.68ms

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

Kamuran

karapy

5 days ago

349.45ms

87.13kb


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

zawwwu

6 days ago

375.65ms

87.20kb

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

Rafik

RafikGadzhiyev

6 days ago

366.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(message: &str) {
        println!("{message}");
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

AKA.MoneyTaker

M4Bo2

6 days ago

393.63ms

87.20kb

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

fyroostr

6 days ago

382.27ms

87.13kb

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

AnKarl

Zythophilus

7 days ago

371.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!("{msg}");
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Éric Villani

TheTrueCaligari

8 days ago

344.63ms

87.16kb

// 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!("{}", m);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Lê Minh Quân

aleister1102

9 days ago

373.16ms

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

Yi Hao

leongyihao

10 days ago

418.63ms

87.20kb

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

MESTRE Sylvain

Shult

10 days ago

438.55ms

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

Muhammad Najib Bala

NAJIB-B

10 days ago

347.07ms

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

Dyaa Adel

dyaa-adel

11 days ago

427.52ms

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

PixelForg

11 days ago

355.68ms

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

ahmedzghal

11 days ago

409.01ms

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

Tomaz Azinhal

tomazinhal

11 days ago

394.02ms

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

Ayushman Rathore

Spartan09

12 days ago

405.11ms

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

Alberto Nidasio

NidasioAlberto

12 days ago

346.95ms

87.20kb

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

Anıl Şenay

anilsenay

12 days ago

364.14ms

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

Deaddy3

12 days ago

344.20ms

87.20kb

// 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) -> () {
        println!("[LOG]: {message}");
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

Evan

0xIchigo

12 days ago

350.46ms

87.13kb

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

Jordan

Jordan-Haidee

14 days ago

330.19ms

87.23kb

// 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!");
}

VLund

VladikPopik

14 days ago

365.53ms

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

Babuuu

aynugek

14 days ago

335.42ms

87.13kb

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

Kyle Diaz

kylediaz

15 days ago

368.30ms

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(m: &str) {
        println!("{}", m);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

TiagONTOP

15 days ago

365.80ms

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(string: &str) {
        println!("{}", string)
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("Hello, World!");
}

SeinPierre

15 days ago

354.26ms

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

norabbito

15 days ago

398.40ms

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

Pavel

webxed

16 days ago

352.02ms

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

Jaded

jaded-it

16 days ago

341.91ms

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

Guilherme Cesário Strachan

strachan

16 days ago

339.37ms

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