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

msned

4 minutes ago

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

Smith, Taylor

a647965_fidelity

2 hours ago

334.89ms

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

jh4vision

5 hours ago

428.87ms

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

Selim Gökmen

sgoekmen

8 hours ago

333.25ms

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(s: &str) {
        println!("[LOG]: {s}");
    }
}

idorocodes

11 hours ago

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

greg95000

a day ago

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

Vitalol

a day ago

356.71ms

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

AyotuntosimiLoye

2 days ago

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

noname

random1106

3 days ago

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

Christophe Mohimont

mohic

3 days ago

399.27ms

87.20kb

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

Yury

Just-Captain

3 days ago

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

Muhammad Rizki Rijal

eezhal92

4 days ago

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

Muhammad Rizki Rijal

eezhal92

4 days ago

356.64ms

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

JIA

bytesxz

4 days ago

356.80ms

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

mickaelactel

4 days ago

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

Paolo Deidda

DePoli97

6 days ago

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

Paolo Deidda

DePoli97

6 days ago

399.09ms

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

amdfxlucas

6 days ago

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

bryan-pignerol

6 days ago

376.84ms

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

firefly

KamisAyaka

7 days ago

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

Solange

SolangeLL

7 days ago

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

Heorhii

Kagev

7 days ago

350.96ms

87.13kb

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

Heorhii

Kagev

7 days ago

364.94ms

87.13kb

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

PikachuMJ

7 days ago

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

RaccoonDX

8 days ago

367.26ms

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

L. Gasc

L-GASC

8 days ago

343.21ms

87.20kb

#![warn(clippy::all)]
// 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!");
}

P S

psvr

8 days ago

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

Varun D

varun-d

9 days ago

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

Akira

itsmewayne

9 days ago

424.88ms

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

rlsh74

9 days ago

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

JD

arukanoido

10 days ago

337.59ms

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

ashishkr2912

10 days ago

376.89ms

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

ashishkr2912

10 days ago

470.31ms

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

Phong H.

doivjpxx

10 days ago

351.51ms

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

DBrouillet

11 days ago

400.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, World!");
}

Jean-Luc Brouillet

jeanlucbr

11 days ago

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

Juan Mejia

juan-mejia

12 days ago

337.67ms

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

Siallus

12 days ago

354.61ms

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

johnson

ssebide

12 days ago

366.62ms

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

Sasank Yadavalli

sasankyadavalli

13 days ago

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

Cristian Banu

cbanu96

14 days ago

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

RASOANOMENJANAHARY Matio Mamy Nantenaina

devlucazh

14 days ago

365.83ms

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

Andrei

Andrey2ec

15 days ago

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

Felipe Marques de Almeida

fmalmeida

15 days ago

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

LewkowskiArkadiusz

15 days ago

360.61ms

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

StevenCanDrink

15 days ago

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

Fanzzzd

16 days ago

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

Fanzzzd

16 days ago

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

Bryan

yuyangchen23

16 days ago

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

achla95

16 days ago

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