Interior Mutability

Rust provides powerful abstractions for managing memory safely and efficiently. One such abstraction is Rc (Reference Counting), which allows multiple ownership of data. When combined with RefCell, it unlocks the ability to mutate data through shared ownership safely at runtime.

In this challenge, you'll use Rc and RefCell together to explore the concept of Interior Mutability in Rust.

Your Task

Implement the following functions to demonstrate shared ownership and interior mutability:

push:
- Accept an Rc<RefCell<Vec<T>>> as input.
- Append an element to the shared vector inside the RefCell.
iterate_and_print_shared_data:
- Take an Rc<RefCell<Vec<T>>> as input.
- Iterate through the vector and print each element.
plus_one:
- Accept an Rc<RefCell<i32> as input.
- Increment the value inside the RefCell by one.

Requirements

Use Rc to share ownership of the vector.
Use RefCell to allow interior mutability.
Avoid using unsafe code.

Hints

If you're stuck, here are some hints to help you solve the challenge:

Click here to reveal hints

Use Rc::clone to share ownership of the vector.
Use RefCell's .borrow_mut() for mutable access and .borrow() for immutable access.
T: Display is needed to format the output with println!.

Editor not available on Mobile!

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

Solutions

AKA.MoneyTaker

M4Bo2

2 days ago

1481.73ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Borrow the vector mutably and push the element
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) 
where
    T: Display, // Ensure T can be printed
{
    // 2. Borrow the data and print each item
    for item in data.borrow().iter() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Borrow the data mutably and increment the value
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

manuelmj

4 days ago

1652.31ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use core::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T)
where T : Display {
    data.borrow_mut().push(element);
    // 1. Finish the function
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where T: Display{
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|element| println!("{}", element));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Ayushman Rathore

Spartan09

5 days ago

1578.89ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    data.borrow().iter().for_each(|e| println!("{}", e));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Dyaa Adel

dyaa-adel

5 days ago

1480.68ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn update_shared_data<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T : Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for item in data.borrow().iter() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut item = data.borrow_mut();
    *item = *item + 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

automata-studio

5 days ago

1429.92ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) 
where T: Display
{
    // 2. Borrow the data and print each item
    for el in data.borrow().iter() {
        println!("{}", el)
    } 
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

ludovicknecht

8 days ago

1326.06ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) 
where T: Display,
{
    // 2. Borrow the data and print each item
    for element in data.borrow().iter() {
        println!("{}", element);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

iamforgettable

9 days ago

1370.98ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) 
  where T: Display {
    // 2. Borrow the data and print each item
    for item in data.borrow().iter() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Jun Huang

leemars

9 days ago

1686.32ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|x| {
        println!("{}", x);
    });
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Algorab

10 days ago

1391.70ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn update_shared_data<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|x| println!("{}", x));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() +=1;
}
pub fn push(data: Rc<RefCell<Vec<i32>>>, element: i32) {
    data.borrow_mut().push(element);
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Jordan

Jordan-Haidee

11 days ago

1434.81ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    let mut x = data.borrow_mut();
    x.push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for d in data.borrow().iter() {
        println!("{}", d);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut x = data.borrow_mut();
    *x += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Jordan

Jordan-Haidee

11 days ago

1527.23ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    let mut x = data.borrow_mut();
    x.push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for d in data.borrow().iter() {
        println!("{}", d);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut x = data.borrow_mut();
    *x += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Jordan

Jordan-Haidee

11 days ago

1630.94ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    let mut x = data.borrow_mut();
    x.push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for d in data.borrow().iter() {
        println!("{}", d);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut x = data.borrow_mut();
    *x += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Kyle Diaz

kylediaz

12 days ago

1359.97ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
    where T: Display
{
    // 2. Borrow the data and print each item
    for d in data.borrow().iter() {
        println!("{}", d);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Nikita Smirnov

Nismirno

13 days ago

1424.65ms

93.84kb

use std::cell::RefCell;
use std::fmt::{Debug, Display};
use std::ops::DerefMut;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where
    T: Display + Debug,
{
    data.borrow().iter().for_each(|i| println!("{}", i));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut().deref_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

alemack17

14 days ago

1338.82ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for i in data.borrow().iter(){
        println!("{}",*i);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut()+=1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Kenneth Love

kennethlove

14 days ago

1351.84ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for line in data.borrow().iter() {
        println!("{}", line.to_string());
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut value = data.borrow_mut();
    *value += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Christopher Nielson

c-nielson

16 days ago

1294.31ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    for elem in data.borrow().iter() {
        println!("{}", elem);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

rawar089

16 days ago

1389.16ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    for item in data.borrow().iter() {
        println!("{}", item);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Elliott Draper

ejdraper

19 days ago

1416.89ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T> (data: Rc<RefCell<Vec<T>>>, element: T) where T: std::fmt::Display {
    let mut arr = data.borrow_mut();
    arr.push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) where T: std::fmt::Display {
    for o in data.borrow().iter() {
        println!("{}", o);
    }
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    let mut num = data.borrow_mut();
    *num += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

kosay

sarub0b0

19 days ago

1586.77ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    data.borrow().iter().for_each(|x| println!("{}", x));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *(data.borrow_mut()) += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Oebelus

oebelus

21 days ago

1602.35ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn update_shared_data<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>)
where
    T: Display,
{
    data.borrow_mut().iter().for_each(|x| println!("{}", x));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1
}
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    update_shared_data(data, element);
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

TaiPoole

22 days ago

1495.84ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn update_shared_data<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) where T: Display {
    data.borrow().iter().for_each(|x| println!("{}", x))
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *data.borrow_mut() += 1;
}
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, item: T) {
    update_shared_data(Rc::clone(&data), item)
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Justin Maillet

justy777

23 days ago

1625.17ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    data.borrow().iter().for_each(|item| println!("{item}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *(data.borrow_mut()) += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Jonathan Voss

jvoss

23 days ago

1320.44ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
// this function definition was wrong out of the box
// pub fn update_shared_data<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: std::fmt::Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|i| println!("{i}"));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Jim Lawton

jimlawton

23 days ago

1406.00ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    (*data).borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    (*data).borrow().iter().for_each(|x| { println!("{x}");});
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    *(*data).borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

Stefan Roas

sroas

24 days ago

1385.56ms

93.84kb

use std::cell::RefCell;
use std::fmt::Display;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T: Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|d| {
        println!("{d}");
    });
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    *data.borrow_mut() += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

dawwestk

a month ago

1339.85ms

93.84kb

use std::cell::RefCell;
use std::ops::Add;
use std::rc::Rc;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T>(data: Rc<RefCell<Vec<T>>>) 
where
    T: std::fmt::Display
{
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|d| println!("{}", d));
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut borrowed = data.borrow_mut();
    *borrowed = borrowed.add(1);
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}

PangoSea

kapaseker

a month ago

1420.19ms

93.84kb

use std::cell::RefCell;
use std::rc::Rc;
use std::fmt::Display;
pub fn push<T>(data: Rc<RefCell<Vec<T>>>, element: T) {
    // 1. Finish the function
    data.borrow_mut().push(element);
}
pub fn iterate_and_print_shared_data<T:Display>(data: Rc<RefCell<Vec<T>>>) {
    // 2. Borrow the data and print each item
    data.borrow().iter().for_each(|element| {
        println!("{}", element);
    })
}
pub fn plus_one(data: Rc<RefCell<i32>>) {
    // 3. Finish the function
    let mut cell = data.borrow_mut();
    *cell += 1;
}
// Example usage
pub fn main() {
    let shared_data = Rc::new(RefCell::new(vec![1, 2, 3]));
    // Updating shared data
    push(Rc::clone(&shared_data), 4);
    push(Rc::clone(&shared_data), 5);
    // Iterating and printing shared data
    println!("Shared Data:");
    iterate_and_print_shared_data(Rc::clone(&shared_data));
    let my_num = Rc::new(RefCell::new(5));
    plus_one(Rc::clone(&my_num));
    assert_eq!(*my_num.borrow(), 6, "Value was not incremented correctly.");
}