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

T4D4

T4D4-IU

15 hours ago

348.47ms

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

Nick Nguyen

nickngn

a day ago

356.56ms

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

Corny

CorndogMillionaire

a day ago

331.92ms

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

Slawek J.

slawekpl81

a day ago

359.11ms

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

jpruitt77

a day ago

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

Tim Bugai

tbugai

a day ago

368.33ms

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

Victor Gonzalez

victoranto

a day ago

377.22ms

87.20kb

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

maliklambda

a day ago

358.14ms

87.18kb

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

Anish Lushte

AnishLushte07

2 days ago

356.62ms

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

cjcela

2 days ago

357.51ms

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

mohamedsoftware1

3 days ago

345.47ms

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

Roy Perry

roypery2010

4 days ago

433.29ms

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

jaime

jaime0815

4 days ago

335.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(m: &str) {
        println!("[LOG]:{{ {} }}", m);
    }
}
// Example usage:
pub fn main() {
    Logger::log_message("This is a test log.");
}

jaime

jaime0815

4 days ago

348.05ms

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("This is a test log.");
}

Vitalii Bedletskyi

VitaliiBedletskyi

4 days ago

396.73ms

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

venkatcg00

6 days ago

337.90ms

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

mihaya

mihaya03

6 days ago

350.59ms

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

Paweł

pawelkrystkiewicz

6 days ago

359.43ms

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

Jeffrey Au

fly88oj

6 days ago

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

Jeffrey Au

fly88oj

6 days ago

383.85ms

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

Emmanuel Izuchukwu

NobleSalt

7 days ago

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

hung-dt

7 days ago

334.43ms

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

zibuyu28

7 days ago

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

sorero2

7 days ago

340.08ms

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

James Meadows

jamesmeadows7

7 days ago

388.18ms

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

ro011110ot

8 days ago

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

StevenCanDrink

8 days ago

352.08ms

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

Eric Bastarache

ericbastarache

8 days ago

398.93ms

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

j-tesla

8 days ago

397.98ms

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

de2Zotjes

8 days ago

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

Daniil Tatarinov

idkwhttsay

8 days ago

422.47ms

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

Henouille Aymeric

AymericHenouille

9 days ago

347.67ms

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

szzs963

9 days ago

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

Jaroslav Patočka

Rikatemu

9 days ago

386.19ms

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

WinterLily

9 days ago

340.56ms

87.13kb

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

Shinolr

9 days ago

427.47ms

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

Erick Karanja

Erickkaranja

10 days ago

355.33ms

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

oddtempo

11 days ago

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

Thomas Favrel

ThomasFavrel

11 days ago

353.04ms

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

Baily

baily-zhang

11 days ago

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

Atanas Krondev

AtanasKrondev

11 days ago

337.49ms

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

Alexandra Lunhol

Alexandra230

11 days ago

354.11ms

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

KirilDz

12 days ago

379.34ms

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

Ryan Williams

ryanw060

13 days ago

366.66ms

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

Caleb Williamson

c-willi

13 days ago

339.49ms

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

Camden

CamdenForbes

13 days ago

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

bpgswami25

13 days ago

357.45ms

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

Zolenf

13 days ago

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

UDAY KIRAN

udaykirancodes

13 days ago

537.54ms

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

Mehmet ÇETİN

wwdd1

13 days ago

366.54ms

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