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

mwheeleraus

14 hours ago

3.15ms

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

Piotr Baranowski

piotrbar250

20 hours ago

3.08ms

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

murdurn

a day ago

3.85ms

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

Eliettetheegeek

a day ago

2.93ms

81.58kb

// 1. Define the struct
pub struct Counter{
    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
    }
}
// 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);
}

PreppyMiguel

lusuo9

a day ago

3.62ms

81.58kb

// 1. Define the struct
pub struct Counter {
    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
    }
}
// 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);
}

PreppyMiguel

lusuo9

a day ago

3.13ms

81.58kb

// 1. Define the struct
pub struct Counter {
    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
    }
}
// 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);
}

arameop

a day 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) -> i32 {
        self.count += 1;
        self.count
    }
    pub fn decrement(&mut self) -> i32 {
        self.count -= 1;
        self.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);
}

Álex Frías

alexwebdev05

a day ago

4.97ms

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

0M3REXE

2 days ago

3.47ms

81.58kb

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

Hariom

om-secadvice

2 days ago

3.45ms

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

Hariom

om-secadvice

2 days ago

3.30ms

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

khadre07

2 days ago

3.15ms

81.58kb

// 1. Define the struct
pub struct Counter {
    pub counter: i32,
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self{
        return Self {
            counter: 0,
        }
    }
    pub fn increment(&mut self) {
        self.counter = self.counter + 1;
    }
    pub fn decrement(&mut self) {
       self.counter = self.counter - 1;
    }
    pub fn get_count(&self) -> i32{
        return self.counter;
    }
}
// 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);
}

humeey4

2 days ago

2.93ms

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

poppyer9

4 days ago

3.03ms

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

Yuki Nagase

nonanne

4 days ago

3.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);
}

DjukicDragan01

4 days ago

3.15ms

81.58kb

// 1. Define the struct
pub struct Counter{
 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);
}

azmahflameheart

4 days ago

3.07ms

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

Kourosh Mozafari

kmozafari

4 days ago

2.92ms

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

Sukemcute

4 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 {
        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);
}

Vendra000

4 days ago

3.30ms

81.58kb

// 1. Define the struct
pub struct Counter{
    count: i32
}
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);
}

emiludenz

5 days ago

3.23ms

81.58kb

pub struct Counter {
    count: i32,
}
impl Counter {
    pub fn new() -> Counter {
        return Counter { count: 0 };
    }
}
impl Counter {
    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;
    }
}
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);
}

Egu0

egu0

5 days ago

3.08ms

81.58kb

pub struct Counter {
    pub count: i32,
}
impl Default for Counter {
    fn default() -> Counter {
        Counter::new()
    }
}
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);
}

LawisChen

6 days ago

3.14ms

81.58kb

// 1. Define the struct
pub struct Counter(i32);
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Counter {
        Counter(0)
    }
    pub fn increment(&mut self) {
        self.0 += 1;
    }
    pub fn decrement(&mut self) {
        self.0 -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.0
    }
}
// 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);
}

Özgür

AyikOzgur

6 days ago

3.24ms

81.58kb

// 1. Define the struct
pub struct Counter {
    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
    }
}
// 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);
}

Alexey Lisov

BaldiSlayer

6 days ago

3.22ms

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

Marouan Boulahtouf

MBoulahtouf

7 days ago

3.53ms

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

ffrie

7 days ago

3.02ms

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

Ramon Silva

rsilva1

8 days ago

3.00ms

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

aureliothuerch

8 days ago

3.12ms

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

Anthony Young

A-Young-Git

9 days ago

3.95ms

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

Timmy

sha2dow4

9 days ago

3.43ms

81.58kb

// 1. Define the struct
pub struct Counter {
    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
    }
}
// 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);
}

0xMindset

ijustbuilddifferentdude

9 days ago

34.43ms

81.58kb

// 1. Define the struct
pub struct Counter {
    count: i32
}
// 2. Implement the associated function and methods
impl Counter {
    pub fn new() -> Self {
        let count = 0;
        Self {
            count
        }
    }
    pub fn increment(&mut self) {
        self.count += 1
    }
    pub fn get_count(&self) -> i32 {
        self.count
    }
    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);
}

Dani-Drk

9 days ago

3.01ms

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

Snoweuph

snoweuph

10 days ago

3.07ms

81.58kb

pub struct Counter {
    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
    }
}

Hossein Adib

hosseinadib-hub

10 days ago

4.09ms

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

Jan-hjh

10 days ago

3.35ms

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

winter

winter-08

10 days ago

4.79ms

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

penmanglewood

10 days ago

4.07ms

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

vqk-2003

11 days ago

2.84ms

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

exeris

11 days ago

3.18ms

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 {
        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);
}

makinpaper

11 days ago

16.71ms

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

Dan Wayne

danwayne-me

12 days ago

2.98ms

81.58kb

// 1. Define the struct
pub struct Counter {
    val: i32
}
impl Counter {
    pub fn new() -> Self {
        Self {val: 0}
    }
    pub fn increment(&mut self) {
        self.val += 1;
    }
    pub fn decrement(&mut self) {
        self.val -= 1;
    }
    pub fn get_count(&self) -> i32 {
        self.val
    }
}
// 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);
}

vivek

vivek-inavalli

12 days ago

19.35ms

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

Amit Patel

amitpatel-wstf

12 days ago

3.75ms

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

Rishika Sharma

Rishika-dev

12 days ago

3.94ms

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

fasolyee

fasolyeedev

12 days ago

3.27ms

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

Yonny Sanchez

yonnylsb

13 days ago

4.12ms

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

Alex

ravsii

13 days ago

3.94ms

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

batblerone

13 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()-> 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);
}

DebroyeAntoine

14 days ago

3.15ms

81.58kb

// 1. Define the struct
pub struct Counter {
    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
    }
}
// 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);
}