Rc<T>

Reference-counted pointers, Rc<T>, are a type of smart pointer in Rust that allow multiple ownership of the same data. This means you can have multiple references to a value, and the value will only be dropped when the last reference is out of scope. This is particularly useful in scenarios where you want to share data between multiple parts of your program without needing to copy it.

In this challenge, you'll use Rc<T> to share data between functions.

Your Task

Implement the functions use_shared_data and share_data_to_other_functions to work with Rc<T>.

use_shared_data:
- Take an Rc<Vec<T>> as argument.
- Loop over each item in the vector and print each element using println!.
share_data_to_other_functions:
- Share the input as a reference-counted pointer 3 times with the given closure.
- Do cheap clones only and avoid deep copying the data.

Hints

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

Click here to reveal hints

Use Rc::new to wrap your vector in an Rc smart pointer.
Use Rc::clone to create new references to the shared data.
For use_shared_data, make sure to use T: Display to allow printing elements with {} formatting.

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

457.21ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T>(data: Rc<Vec<T>>) 
where
    T: std::fmt::Display, // 确保 T 可以被打印
{
    // 1. Loop over each item in the vector and print it using `println!`
    for item in data.iter() {
        println!("{}", item);
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let shared_data = Rc::new(items);
    for _ in 0..3 {
        take_item(Rc::clone(&shared_data));
    }
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

manuelmj

5 days ago

393.90ms

92.44kb

use std::rc::Rc;
use core::fmt::Display;
pub fn use_shared_data<T>(data: Rc<Vec<T>>)
where T: Display {
    // 1. Loop over each item in the vector and print it using `println!`
    let _ = data.iter().for_each(|element| println!("{}",element));
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let shared_data = Rc::new(items); 
    take_item(Rc::clone(&shared_data));
    take_item(Rc::clone(&shared_data));
    take_item(Rc::clone(&shared_data));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Ayushman Rathore

Spartan09

5 days ago

435.22ms

92.44kb

use std::rc::Rc;
use std::fmt::Display;
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    data.iter().for_each(|e| println!("{}", e))
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let shared_numbers = Rc::new(items);
    take_item(Rc::clone(&shared_numbers));
    take_item(Rc::clone(&shared_numbers));
    take_item(Rc::clone(&shared_numbers));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Dyaa Adel

dyaa-adel

5 days ago

379.95ms

92.44kb

use std::rc::Rc;
use std::fmt::Display;
pub fn use_shared_data<T : Display>(data: Rc<Vec<T>>) {
    // 1. Loop over each item in the vector and print it using `println!`
    for item in data.iter() {
        println!("{}", item);
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let rc_data : Rc<Vec<String>> = Rc::new(items);
    take_item(Rc::clone(&rc_data));
    take_item(Rc::clone(&rc_data));
    take_item(Rc::clone(&rc_data));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

automata-studio

5 days ago

404.76ms

92.44kb

use std::rc::Rc;
use std::fmt::Display;
pub fn use_shared_data<T>(data: Rc<Vec<T>>) 
    // 1. Loop over each item in the vector and print it using `println!`
    where T: Display {
    for item in data.iter() {
        println!("{}", item)
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let rc_items = Rc::new(items);
    for _ in 1..=3 {
        take_item(Rc::clone(&rc_items));
    }
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

ludovicknecht

8 days ago

385.35ms

92.44kb

use std::rc::Rc;
use std::fmt::Display;
pub fn use_shared_data<T>(data: Rc<Vec<T>>)
where
    T: Display,
{
    // 1. Loop over each item in the vector and print it using `println!`
    for element in data.iter() {
        println!("{}", element);
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let rc_items = Rc::new(items);
    for _ in 1..=3 {
        take_item(Rc::clone(&rc_items));
    }
    
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

iamforgettable

9 days ago

387.74ms

92.44kb

use std::rc::Rc;
use std::fmt::Display;
pub fn use_shared_data<T>(data: Rc<Vec<T>>) 
  where T: Display
{
    // 1. Loop over each item in the vector and print it using `println!`
    for item in data.iter() {
        println!("{}", item);
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    
    let x = Rc::new(items);
    take_item(Rc::clone(&x));
    take_item(Rc::clone(&x));
    take_item(Rc::clone(&x));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Jun Huang

leemars

9 days ago

384.85ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T: std::fmt::Display>(data: Rc<Vec<T>>) {
    // 1. Loop over each item in the vector and print it using `println!`
    data.iter().for_each(|x| {
        println!("{}", x);
    });
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let rc = Rc::new(items);
    (0..3).into_iter().for_each(|_| {
        take_item(Rc::clone(&rc));
    });
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Algorab

10 days ago

382.56ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T: std::fmt::Display>(data: Rc<Vec<T>>) {
    data.iter().for_each(|x| println!("{}", x));
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let rc = Rc::new(items);
    (0..3).into_iter().for_each(|_| {
        take_item(rc.clone());
    });
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Jordan

Jordan-Haidee

11 days ago

399.71ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T: std::fmt::Display>(data: Rc<Vec<T>>) {
    // 1. Loop over each item in the vector and print it using `println!`
    for d in data.iter() {
        println!("{}", d);
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let x = Rc::new(items);
    for _ in 0..3 {
        take_item(Rc::clone(&x));
    }
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Kyle Diaz

kylediaz

12 days ago

386.53ms

92.44kb

use std::rc::Rc;
use std::fmt::Display;
pub fn use_shared_data<T>(data: Rc<Vec<T>>) where T: Display {
    // 1. Loop over each item in the vector and print it using `println!`
    for d in data.iter() {
        println!("{}", d);
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let items = Rc::new(items);
    for _ in 1..=3 {
        take_item(Rc::clone(&items));
    }
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Nikita Smirnov

Nismirno

13 days ago

392.48ms

92.44kb

use std::{
    fmt::{Debug, Display},
    ops::Deref,
    rc::Rc,
};
pub fn use_shared_data<T>(data: Rc<Vec<T>>)
where
    T: Display + Debug,
{
    // 1. Loop over each item in the vector and print it using `println!`
    data.deref().iter().for_each(|i| println!("{}", i));
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let shared_items = Rc::new(items);
    take_item(Rc::clone(&shared_items));
    take_item(Rc::clone(&shared_items));
    take_item(Rc::clone(&shared_items));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

alemack17

14 days ago

383.41ms

92.44kb

use std::rc::Rc;
use std::fmt::Display;
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    // 1. Loop over each item in the vector and print it using `println!`
    for i in data.iter(){
        println!("{}",*i);
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let tt=Rc::new(items);
    take_item(Rc::clone(&tt));
    take_item(Rc::clone(&tt));
    take_item(Rc::clone(&tt));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Kenneth Love

kennethlove

14 days ago

459.74ms

92.44kb

use std::rc::Rc;
use std::fmt::Display;
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    // 1. Loop over each item in the vector and print it using `println!`
    for line in data.iter() {
        println!("{}", line);
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let items = Rc::new(items);
    take_item(Rc::clone(&items));
    take_item(Rc::clone(&items));
    take_item(Rc::clone(&items));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Christopher Nielson

c-nielson

16 days ago

379.59ms

92.44kb

use std::fmt::Display;
use std::rc::Rc;
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    for item in data.iter() {
        println!("{}", item);
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    let my_rc = Rc::new(items);
    
    take_item(Rc::clone(&my_rc));
    take_item(Rc::clone(&my_rc));
    take_item(Rc::clone(&my_rc));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

rawar089

16 days ago

383.00ms

92.44kb

use std::fmt::Display;
use std::rc::Rc;
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    // 1. Loop over each item in the vector and print it using `println!`
    for i in data.iter() {
        println!("{}",i);
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let items_ref = Rc::new(items);
    take_item(Rc::clone(&items_ref));
    take_item(Rc::clone(&items_ref));
    take_item(Rc::clone(&items_ref));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Elliott Draper

ejdraper

19 days ago

377.79ms

92.44kb

use std::fmt::Display;
use std::rc::Rc;
pub fn use_shared_data<T>(data: Rc<Vec<T>>) where T: Display {
    // 1. Loop over each item in the vector and print it using `println!`
    for o in data.iter() {
        println!("{}", o);
    }
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let rc = Rc::new(items);
    take_item(Rc::clone(&rc));
    take_item(Rc::clone(&rc));
    take_item(Rc::clone(&rc));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

kosay

sarub0b0

19 days ago

453.42ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T: std::fmt::Display>(data: Rc<Vec<T>>) {
    data.iter().for_each(|item| println!("{}", item))
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    let items = Rc::new(items);
    take_item(items.clone());
    take_item(items.clone());
    take_item(items.clone());
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Oebelus

oebelus

21 days ago

408.28ms

92.44kb

use std::{fmt::Display, rc::Rc};
pub fn use_shared_data<T>(data: Rc<Vec<T>>)
where
    T: Display,
{
    data.iter().for_each(|x| println!("{}", x));
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    let rc = Rc::new(items);
    take_item(Rc::clone(&rc));
    take_item(Rc::clone(&rc));
    take_item(Rc::clone(&rc));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

TaiPoole

22 days ago

408.09ms

92.44kb

use std::fmt::Display;
use std::rc::Rc;
pub fn use_shared_data<T>(data: Rc<Vec<T>>) where T: Display {
    data.iter().for_each(|x| println!("{}", x));
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    let rc = Rc::new(items);
    take_item(Rc::clone(&rc));
    take_item(Rc::clone(&rc));
    take_item(Rc::clone(&rc))
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Justin Maillet

justy777

23 days ago

442.97ms

92.44kb

use std::rc::Rc;
use std::fmt::Display;
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    data.iter().for_each(|item| println!("{item}"));
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    let shared_items = Rc::new(items);
    for _ in 0..3 {
        take_item(Rc::clone(&shared_items));
    }
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Jonathan Voss

jvoss

23 days ago

401.18ms

92.44kb

use std::fmt::Display;
use std::rc::Rc;
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    // 1. Loop over each item in the vector and print it using `println!`
    data.iter().for_each(|i| println!("{i}"));
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let shared_items = Rc::new(items);
    for _ in 0..3 {
        take_item(Rc::clone(&shared_items));
    }
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Jim Lawton

jimlawton

23 days ago

431.61ms

92.44kb

use std::fmt::Display;
use std::rc::Rc;
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    (*data).iter().for_each(|x| { println!("{x}"); })
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    let items = Rc::new(items);
    take_item(items.clone());
    take_item(items.clone());
    take_item(items.clone());
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

Stefan Roas

sroas

24 days ago

419.41ms

92.44kb

use std::{fmt::Display, rc::Rc};
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    // 1. Loop over each item in the vector and print it using `println!`
    data.iter().for_each(|d| {
        println!("{d}");
    });
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let items = Rc::new(items);
    take_item(Rc::clone(&items));
    take_item(Rc::clone(&items));
    take_item(Rc::clone(&items));
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

dawwestk

a month ago

374.32ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T>(data: Rc<Vec<T>>)
where
    T: std::fmt::Display
{
    // 1. Loop over each item in the vector and print it using `println!`
    data.iter().for_each(|d| println!("{}", d));
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let r = Rc::new(items);
    for _ in 0..3 {
        take_item(Rc::clone(&r));
    }
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}

PangoSea

kapaseker

a month ago

441.60ms

92.44kb

use std::rc::Rc;
use std::fmt::{Display, Formatter};
pub fn use_shared_data<T:Display>(data: Rc<Vec<T>>) {
    // 1. Loop over each item in the vector and print it using `println!`
    data.iter().for_each(|x| {
        println!("{}", x);
    })
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
    let items = Rc::new(items);
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    take_item(items.clone());
    take_item(items.clone());
    take_item(items.clone());
}
// Example usage
pub fn main() {
    // Example usage of `use_shared_data`
    let shared_numbers = Rc::new(vec![1, 2, 3, 4, 5]);
    println!("Using shared data:");
    use_shared_data(Rc::clone(&shared_numbers));
    // Example usage of `share_data_to_other_functions`
    let strings = vec!["Rust".to_string(), "is".to_string(), "awesome!".to_string()];
    let print_data = |data: Rc<Vec<String>>| {
        println!("Printing shared data:");
        for item in data.iter() {
            println!("{}", item);
        }
    };
    println!("\nSharing data with other functions:");
    share_data_to_other_functions(print_data, strings);
}