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;
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.
Define a unit struct named Logger
.
Implement a Logger::log_message
method that:
&str
message as input.[LOG]: {message}
.Use the unit struct Logger
to call this method.
Logger::log_message("This is a test log.");
// Output: [LOG]: This is a test log.
pub struct Logger;
.impl Logger
block.println!
macro to format and print the message.pub struct Logger;impl Logger { pub fn log_message(message: &str) { println!("{}", message); }}// Example usage:pub fn main() { Logger::log_message("Hello, World!");}
// 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!");}
// 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!");}
pub struct Logger;impl Logger { pub fn log_message(log: &str) { println!("{log}"); }}pub fn main() { Logger::log_message("Hello, World!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// Define a struct named `Logger`pub struct Logger;impl Logger { pub fn log_message(msg: &str) { println!("{msg}"); }}// Implement an associated function `log_message`// That accepts a `&str` and prints the output.// Example usage:pub fn main() { Logger::log_message("Hello, World!");}
// Define a struct named `Logger`pub struct Logger;impl Logger { pub fn log_message(msg: &str) { println!("{msg}"); }}// Implement an associated function `log_message`// That accepts a `&str` and prints the output.// Example usage:pub fn main() { Logger::log_message("Hello, World!");}
// 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!("{}", message.to_string()) }}// Example usage:pub fn main() { Logger::log_message("Hello, World!");}
// 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!");}
// 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(x: &str) { println!("[LOG]: {}", x); }}// Example usage:pub fn main() { Logger::log_message("Hello, World!");}
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.pub struct Logger;impl Logger { pub fn log_message(message: &str) { println!("[LOG]: {}", message) }}// Example usage:pub fn main() { Logger::log_message("Hello, World!");}
// 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!");}
// 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!");}
// Define a struct named `Logger`// Implement an associated function `log_message`// That accepts a `&str` and prints the output.pub struct Logger;// Example usage:pub fn main() { Logger::log_message("Hello, World!");}impl Logger { pub fn log_message(msg: &str) { println!("{}", msg) }}
// Define a struct named `Logger`// Implement an associated function `log_message`// That accepts a `&str` and prints the output.pub struct Logger;// Example usage:pub fn main() { Logger::log_message("Hello, World!");}impl Logger { pub fn log_message(msg: &str) { println!("{}", msg) }}
pub struct Logger();impl Logger { pub fn log_message(text: &str) { println!("[LOG]: {}", text) }}pub fn main() { Logger::log_message("Hello, World!");}
pub struct Logger();impl Logger { pub fn log_message(text: &str) { println!("[LOG]: {}", text) }}pub fn main() { Logger::log_message("Hello, World!");}
// 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); }}
// 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!");}
// 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]{}",log) }}// Example usage:pub fn main() { Logger::log_message("Hello, World!");}
// 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!");}
// 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!");}
// 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!");}
// 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(value: &str) { println!("{value}") }}// Example usage:pub fn main() { Logger::log_message("Hello, World!");}
// 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!");}
pub struct Logger;impl Logger { pub fn log_message(lg_msg: &str) { println!("[LOG]: {}", lg_msg); }}// Example usage:pub fn main() { Logger::log_message("Hello, World!");}
// 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!");}
pub struct Logger;impl Logger { pub fn log_message(message: &str) { println!("[LOG]: {message}"); }}pub fn main() { Logger::log_message("Hello, World!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}
// 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!");}