Methods on Structs

In Rust, methods and associated functions are both defined using impl blocks. While they are similar in some ways, they serve different purposes:

Associated Functions:
- Defined without a self parameter.
- Typically used as constructors or utility functions.
- Called using the struct's name, e.g., StructName::function_name().
Methods:
- Defined with a self parameter (&self, &mut self, or self).
- Operate on an instance of the struct.
- Called on a struct instance using the dot syntax, e.g., instance.method_name().

In the previous challenge, the Logger::log_message was an associated function because it didn't take self as a parameter. In this challenge, you will learn how to create methods that operate on struct instances.

Your Task

Define a struct Counter that represents a simple counter. Implement methods on this struct to increment, decrement, and get the current count. This will help you understand how to define and use methods that operate on a struct instance.

Requirements

Define a struct Counter with a single field count of type i32.
Define a new associated function that acts as a constructor and initializes the count field to 0.
Implement the following methods for Counter:
- increment: Increments the counter by 1.
- decrement: Decrements the counter by 1.
- get_count: Returns the current count.
Ensure these methods use the correct self parameter type (&self or &mut self) based on their behavior.
Make the count field private and provide a public constructor Counter::new that initializes the count to 0.

Example Test

let mut counter = Counter::new();
counter.increment();
counter.increment();
assert_eq!(counter.get_count(), 2);
 
counter.decrement();
assert_eq!(counter.get_count(), 1);

Hints

If you're stuck, you can check out these hints:

Click here to reveal hints

Fort he increment and decrement methods, use &mut self as the parameter type.
Use self.count += 1 to modify the counter in the increment method.
Use self.count -= 1 to modify the counter in the decrement method.
For get_count, use &self and return the value of self.count.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Madhankumar Anandan

amkumar072

4 hours ago

4.55ms

81.58kb

// 1. Define the struct
pub struct Counter{
    pub count: i32
}
// 2. Implement the associated function and methods
impl Counter{
    pub fn new()-> Self{
        Self{
            count: 0
        }
    }
    pub fn increment(&mut self){
        self.count+= 1;
    }
    pub fn decrement(&mut self){
        self.count-=1;
    }
    pub fn get_count(&self) -> i32{
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Elizabeth Doughty

Thymelizabeth

6 hours ago

3.46ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        Self {
            count: 0
        }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

kustrun

7 hours ago

3.23ms

81.58kb

// 1. Define the struct
pub struct Counter {
    pub count: i32,
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter {
            count: 0
        }
    }
    pub fn increment(&mut self) {
        self.count += 1
    }
    pub fn decrement(&mut self) {
        self.count -= 1
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Lauri Sarap

LauriSarap

a day ago

3.41ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        Self {
            count: 0
        }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        return self.count;
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Taufik Hidayat

tfkhdyt

a day ago

3.77ms

81.58kb

// 1. Define the struct
pub struct Counter {
    counter: i64,
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        Self { counter: 0 }
    }
    pub fn increment(&mut self) {
        self.counter += 1;
    }
    pub fn decrement(&mut self) {
        self.counter -= 1;
    }
    pub fn get_count(&self) -> i64 {
        self.counter
    }
}
impl Default for Counter {
    fn default() -> Self {
        Self::new()
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Icarus

IcarusxB

a day ago

3.62ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32,
}
impl Counter{
    pub fn new()->Counter{
        Counter{
            count: 0,
        }
    }
    pub fn increment(&mut self){
        self.count += 1
    }
    pub fn decrement(&mut self){
        self.count -= 1
    }
    pub fn get_count(&self)->i32{
        self.count
    }
    }
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

G Towers

gtowers-dukosi

a day ago

3.42ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter { count: 0 }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Lucas Deprit

lucasdeprit

a day ago

5.21ms

81.58kb

// 1. Define the struct
pub struct Counter {
    pub count: i32,
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter {
            count: 0,
        }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Icarus

IcarusxB

2 days ago

3.96ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32,
}
impl Counter{
    pub fn new()->Counter{
        Counter{
            count: 0,
        }
    }
    pub fn increment(&mut self){
        self.count += 1
    }
    pub fn decrement(&mut self){
        self.count -= 1
    }
    pub fn get_count(&self)->i32{
        self.count
    }
    }
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Facundo Hernandez

facuhernandez99

2 days ago

3.28ms

81.58kb

// 1. Define the struct
pub struct Counter{
    count: i32
}
// 2. Implement the associated function and methods
impl Counter{
    pub fn new() -> Self{
        Counter{count: 0}
    }
    pub fn increment(&mut self){
        self.count += 1;
    }
    pub fn decrement(&mut self){
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

vojta stefan

vojtastefan

2 days ago

3.79ms

81.58kb

// 1. Define the struct
pub struct Counter{
     count:i32,
}
// 2. Implement the associated function and methods
impl Counter{
    pub fn new()-> Counter {
        Counter{
            count : 0,
        }
    }
    pub fn increment(&mut self) {
        self.count +=1
    }
    pub fn decrement(&mut self){
        self.count -= 1
    }
    pub fn get_count(&self) -> i32{
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

JackY

Scorpio24

2 days ago

4.17ms

81.58kb

// 1. Define the struct
pub struct Counter{
    count: i32,
}
// 2. Implement the associated function and methods
impl Counter{
    pub fn new() -> Counter{
        Counter{
            count: 0,
        }
    }
    pub fn increment(&mut self){
        self.count += 1;
    }
    pub fn decrement(&mut self){
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32{
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Hung Dinh

nhdinh

3 days ago

3.57ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32,
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter { count: 0 }
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

amaneru

7ma8no9

3 days ago

3.31ms

81.58kb

// 1. Define the struct
pub struct Counter {
    pub count: i32,
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        Counter {
            count: 0,
        }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    
    pub fn get_count(&self) -> i32 {
        self.count
    } 
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Pranav Garg

PranavGarg01

4 days ago

4.34ms

81.58kb

// 1. Define the struct
pub struct Counter {
    pub count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter {
            count : 0
        }
    }
    
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32{
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Heatiche Mix

HeaticheTakachi

4 days ago

3.86ms

81.58kb

// 1. Define the struct
pub struct Counter {
    pub count: i32
}
impl Counter {
    pub fn new() -> Counter{
        Counter{
            count: 0
        }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32{
        self.count
    }
}
// 2. Implement the associated function and methods
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Léa Narzis

lean-apple

4 days ago

4.39ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        Counter {
            count: 0
        }
    }
    pub fn increment(&mut self) {
        self.count +=1;
    }
    pub fn decrement(&mut self) {
        self.count -=1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

happines

rhithesh

5 days ago

3.36ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
impl Counter {
    pub fn new() -> Self {
        Counter{count: 0}
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// 2. Implement the associated function and methods
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Artyom Chebotarev

Derik117

5 days ago

9.26ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
impl Counter {
    pub fn new() -> Self {
        Counter{count: 0}
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// 2. Implement the associated function and methods
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Kamuran

karapy

5 days ago

3.39ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter {
            count: 0
        }
    }
    pub fn increment(& mut self) {
        self.count = &self.count + 1
    }
    pub fn decrement(& mut self) {
        self.count = &self.count - 1
    }
    pub fn get_count(&self)-> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

zawwwu

6 days ago

4.25ms

81.58kb

pub struct Counter {
    count: i32
}
impl Counter {
    pub fn new() -> Counter {
        Counter{count: 0}
    }
    pub fn increment(&mut self) {
        self.count += 1
    }
    pub fn decrement(&mut self) {
        self.count -= 1
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Rafik

RafikGadzhiyev

6 days ago

3.47ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        return Counter {
            count: 0
        };
    }
    pub fn get_count(&self) -> i32 {
        return self.count;
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

AKA.MoneyTaker

M4Bo2

6 days ago

3.71ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32,
}
// 2. Implement the associated function and methods
impl Counter {
    // Associated function to create a new Counter instance
    pub fn new() -> Self {
        Counter { count: 0 }
    }
    // Method to increment the counter by 1
    pub fn increment(&mut self) {
        self.count += 1;
    }
    // Method to decrement the counter by 1
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    // Method to get the current count
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

AnKarl

Zythophilus

7 days ago

4.29ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32,
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        Self {count: 0}
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Éric Villani

TheTrueCaligari

8 days ago

3.16ms

81.58kb

pub struct Counter {
    count: i32,
}
impl Counter {
    pub fn new() -> Counter {
        Counter{ count: 0 }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Lê Minh Quân

aleister1102

9 days ago

3.14ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter {
            count: 0
        }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Yi Hao

leongyihao

10 days ago

3.94ms

81.58kb

pub struct Counter {
	count: i32
}
impl Counter {
	pub fn new() -> Self {
		Counter { count: 0 }
	}
	pub fn increment(&mut self) {
		self.count += 1;
	}
	pub fn decrement(&mut self) {
		self.count -= 1;
	}
	pub fn get_count(&self) -> i32 {
		self.count
	}
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

MESTRE Sylvain

Shult

10 days ago

3.21ms

81.58kb

// 1. Define the struct
pub struct Counter{
    count: i32,
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter { 
            count: 0 
        }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        return self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Muhammad Najib Bala

NAJIB-B

10 days ago

3.39ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
impl Counter {
    pub fn increment(&mut self) {
        self.count += 1
    }
      pub fn decrement(&mut self) {
        self.count -= 1
    }
       pub fn get_count(&self) -> i32 {
        self.count
    }
    pub fn new() -> Counter {
        Counter {
            count: 0
        }
    }
}
// 2. Implement the associated function and methods
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Nanle100

10 days ago

3.77ms

81.58kb


pub struct Counter {
    pub count: i32
}
impl Counter {
    pub fn new() -> Counter{
        Counter {
            count: 0
        }
    }
    pub fn increment(&mut self) {
        self.count+=1;
    }
    pub fn decrement(&mut self) {
        self.count -=1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

PixelForg

11 days ago

4.30ms

81.58kb

pub struct Counter {
    pub count: i32
}
impl Counter {
    pub fn new() -> Counter{
        Counter {
            count: 0
        }
    }
    pub fn increment(&mut self) {
        self.count+=1;
    }
    pub fn decrement(&mut self) {
        self.count -=1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Dyaa Adel

dyaa-adel

11 days ago

3.95ms

81.58kb

// 1. Define the struct
pub struct Counter {
    pub count : i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter {
            count : 0
        }
    }
    pub fn increment(&mut self) {
        self.count+= 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

ahmedzghal

11 days ago

3.61ms

81.58kb

// 1. Define the struct
pub struct Counter {
    pub count:i32
}
impl Counter {
    pub fn new()-> Counter {
        Counter {
            count:0
        }
    }
    pub fn increment(&mut self) {
        self.count+=1
    }
    pub fn decrement(&mut self) {
        self.count-=1
    }
    pub fn get_count(&self)->i32 {
        self.count
    }
}
// 2. Implement the associated function and methods
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Evan

0xIchigo

11 days ago

6.46ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32,
}
impl Counter {
    pub fn new() -> Counter {
        Counter {
            count: 0
        }
    }
    
    pub fn increment(&mut self) {
        self.count += 1
    }
    pub fn decrement(&mut self) {
        self.count -= 1
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Tomaz Azinhal

tomazinhal

11 days ago

3.43ms

81.58kb

// 1. Define the struct
pub struct Counter {
    value: i32,
}
impl Counter {
    pub fn new() -> Self {
        Counter { value:0 }
    }
    pub fn increment(&mut self) {
        self.value += 1;
    }
    pub fn decrement(&mut self) {
        self.value -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.value
    }
}
// 2. Implement the associated function and methods
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Ayushman Rathore

Spartan09

12 days ago

6.68ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        Counter { count: 0 }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Alberto Nidasio

NidasioAlberto

12 days ago

3.26ms

81.58kb

// 1. Define the struct
pub struct Counter {
    value: i32,
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        Self {
            value: 0
        }
    }
    pub fn increment(&mut self) {
        self.value += 1;
    }
    pub fn decrement(&mut self) {
        self.value -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.value
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Anıl Şenay

anilsenay

12 days ago

3.37ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32,
}
impl Counter {
    pub fn new() -> Counter {
        Counter {
            count: 0,
        }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Deaddy3

12 days ago

5.54ms

81.58kb

// 1. Define the struct
pub struct Counter{
    status: isize,
}
impl Counter {
    pub fn increment(&mut self) -> () {
        self.status += 1;
    }
    pub fn decrement(&mut self) -> () {
        self.status -= 1;
    }
    pub fn get_count(&self) -> isize {
        self.status
    }
    pub fn new() -> Counter {
        Counter{
            status: 0,
        }
    }
}
// 2. Implement the associated function and methods
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Jordan

Jordan-Haidee

14 days ago

3.17ms

81.58kb

// 1. Define the struct
pub struct Counter {
    pub count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        Counter {
            count: 0
        }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

VLund

VladikPopik

14 days ago

3.17ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
impl Counter {
    pub fn new() -> Self {
        Counter {
            count: 0
        }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// 2. Implement the associated function and methods
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Babuuu

aynugek

14 days ago

3.18ms

81.58kb

pub struct Counter {
    pub count: i32,
}
impl Counter {
    pub fn new() -> Self {
        Self { count: 0 }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Kyle Diaz

kylediaz

15 days ago

3.12ms

81.58kb

// 1. Define the struct
pub struct Counter {
    pub count: i32,
}
impl Counter {
    pub fn new() -> Counter {
        Counter{ count: 0 }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// 2. Implement the associated function and methods
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

TiagONTOP

15 days ago

4.23ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
impl Counter {
    pub fn new() -> Counter {
        Counter{
            count: 0
        }
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
    pub fn increment(&mut self) {
        self.count += 1
    }
     
    pub fn decrement(&mut self) {
        self.count -= 1
    }
}
// 2. Implement the associated function and methods
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

SeinPierre

15 days ago

3.21ms

81.58kb

// 1. Define the struct
pub struct Counter{
    count : i32,
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter{
        Counter {
            count : 0,
        }
    }
    pub fn increment (&mut self) {
        self.count += 1;
    }
    pub fn decrement (&mut self) {
        self.count -= 1;
    }
    pub fn get_count (&self) -> i32{
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

norabbito

15 days ago

3.17ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter {count: 0}
    }
    pub fn increment(&mut self) {
        self.count += 1
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Pavel

webxed

15 days ago

6.56ms

81.58kb

// 1. Define the struct
pub struct Counter
{
    val : i32
}
// 2. Implement the associated function and methods
impl Counter
{
    pub fn new () -> Self {
        Counter
        {
            val: 0
        }
    }
    pub fn increment(&mut self)
    {
        self.val += 1;
    }
    pub fn decrement(&mut self)
    {
        self.val -= 1;
    }    
    pub fn get_count(&self) -> i32
    {
        return self.val;
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Jaded

jaded-it

16 days ago

3.21ms

81.58kb

// 1. Define the struct
pub struct Counter(i32);
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        Counter(0)
    }
    pub fn get_count(&self) -> i32 {
        self.0
    }
    pub fn increment(&mut self) {
        self.0 += 1;
    }
    pub fn decrement(&mut self) {
        self.0 -= 1;
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

Guilherme Cesário Strachan

strachan

16 days ago

2.89ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        Self {count: 0}
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}

McToady.eth

McCoady

16 days ago

2.99ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32,
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter { count: 0 }
    }
    pub fn increment(&mut self) {
        self.count += 1;
    }
    pub fn decrement(&mut self) {
        self.count -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
}
// Example use case
pub fn main() {
    let mut counter = Counter::new();
    counter.increment();
    assert_eq!(counter.get_count(), 1);
    counter.increment();
    counter.increment();
    assert_eq!(counter.get_count(), 3);
    counter.decrement();
    assert_eq!(counter.get_count(), 2);
    counter.decrement();
    counter.decrement();
    assert_eq!(counter.get_count(), 0);
}