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

Oleksandr Vechirko

alexvechirko

14 hours ago

403.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.to_string())
  }
}

Luigi Terrone

LuigiTer

a day ago

362.10ms

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

KuuShyn

a day ago

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

Heino Mortensen

hmortensen83

2 days ago

412.05ms

87.27kb

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

Camiam144

2 days ago

341.35ms

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

Karol Płatkowski

spoohie

2 days ago

370.23ms

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

0x0f1

Paul4673

3 days ago

363.79ms

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

0x0f1

Paul4673

3 days ago

338.41ms

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

CtoRust

3 days ago

343.57ms

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

Ushakov Andrey

stdstring

4 days ago

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

Kr0wZ

4 days ago

350.64ms

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

Thibault Guimbert

TGuimbert

4 days ago

340.88ms

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

dattruongdev

5 days ago

361.88ms

87.13kb

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

Sarthak Mishra

sithtsar

5 days ago

372.48ms

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

Tri Nguyen

nguyentri

7 days ago

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

DragonFyre2k15

7 days ago

337.96ms

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

DoughRing

7 days ago

367.01ms

87.20kb

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

BoΠeShΔdϴw³

B0neShAd0w

8 days ago

340.94ms

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

wertion555

9 days ago

424.47ms

87.20kb

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

Lucop1911

9 days ago

371.75ms

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

Rocky.C

cloki0610

9 days ago

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

Rocky.C

cloki0610

9 days ago

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

Pierre Gordo

PierreGordo

10 days ago

352.75ms

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

s.i

ssmi75

11 days ago

369.34ms

87.20kb

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

xxxxsk

11 days ago

412.70ms

87.20kb

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

alexanderreznicek

alexreznicekwork

11 days ago

389.46ms

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

Muhammad Ahmad

ahmadajmalcute

12 days ago

378.60ms

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

Gurrag09847

12 days ago

422.54ms

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

ikatlinsky

12 days ago

369.30ms

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

AndrewDane

12 days ago

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

Satya Sundar Sahu

satya200

12 days ago

347.22ms

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

Gomathi Shankar

gomathishankar37

12 days ago

339.94ms

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

zzispp

12 days ago

350.17ms

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

Jon Meade

meadej

13 days ago

326.42ms

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

Enes

enesscevik

13 days ago

393.54ms

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

Abhishek Sharma

soro-kuraima

13 days ago

345.26ms

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

hahu07

13 days ago

330.98ms

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

abelneo

abel-cod

14 days ago

384.38ms

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

silaskoemen

14 days ago

358.94ms

87.20kb

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

virvid

14 days ago

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

diucicd

14 days ago

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

esl

esl07

15 days ago

346.95ms

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

Naomi Peori

ooPo

16 days ago

368.23ms

87.13kb

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

HusseinAbdelhamid

16 days ago

365.71ms

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

Smith Cruise

Smith-Cruise

17 days ago

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

Tommy

verse215

17 days ago

348.42ms

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

Marius Gehrmann

MGehrmann

18 days ago

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

Gabriel Menezes

GMNDS

18 days ago

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

ALDebugs

19 days ago

378.77ms

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

msned

19 days ago

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