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

StevenCanDrink

2 days ago

361.29ms

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

Chih Ying Yen

xavierforge

3 days ago

396.53ms

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(|item| 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 items = Rc::new(items);
    (0..3).for_each(|_| 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);
}

amdfxlucas

5 days ago

402.82ms

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

undefeated_

boyboi86

7 days ago

415.51ms

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(|a| println!("{}", a));
}
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 item = Rc::new(items);
    (0..3).for_each(|_| take_item(Rc::clone(&item)));
}
// 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);
}

GunGraveCpp

9 days ago

392.82ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T: std::fmt::Display>(data: Rc<Vec<T>>) {
    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>>),
{
    let val = Rc::new(items);
    for _i in 0..3 {
        take_item(val.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);
}

toto

11 days ago

414.73ms

92.44kb

use std::{fmt::Display, 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!`
    data.iter().for_each(|value| println!("{value}"));
}
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);
}

manu3618

13 days ago

391.76ms

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 elt in data.iter() {
        println!("{}", &elt);
    }
}
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 data = Rc::new(items);
    for _ in 0..3 {
        take_item(Rc::clone(&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);
}

Lvfalue

14 days ago

401.08ms

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.clone().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>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let data = Rc::new(items); 
    take_item(Rc::clone(&data));
    take_item(Rc::clone(&data));
    take_item(Rc::clone(&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);
}

visanr

17 days ago

404.28ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T: std::fmt::Display>(data: Rc<Vec<T>>) {
    for item in data.iter() {
        println!("{}", item);
    }
    // 1. Loop over each item in the vector and print it using `println!`
}
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);
    take_item(Rc::clone(&shared_items));
    take_item(Rc::clone(&shared_items));
    take_item(Rc::clone(&shared_items));
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
}
// 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);
}

AtlasVakyrie

22 days ago

373.19ms

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

Luka Bračun

lbracun

22 days ago

383.43ms

92.44kb

use std::{fmt::Display, rc::Rc};
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 rc = Rc::new(items);
    take_item(rc.clone());
    take_item(rc.clone());
    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);
}

bzdula

22 days ago

435.17ms

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!`
    for item in data.as_ref() {
        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 = Rc::new(items);
    take_item(rc.clone());
    take_item(rc.clone());
    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);
}

Wouter

WouterMartens

a month ago

382.33ms

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 = Rc::new(items);
    take_item(Rc::clone(&shared));
    take_item(Rc::clone(&shared));
    take_item(Rc::clone(&shared));
}
// 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);
}

m1031

monorail103

a month ago

530.16ms

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 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 reference = Rc::new(items);
    take_item(Rc::clone(&reference));
    take_item(Rc::clone(&reference));
    take_item(Rc::clone(&reference));
}
// 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);
}

Daniel Mestas

miel-codeai

a month ago

451.94ms

92.44kb

use std::{fmt::Display, rc::Rc};
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    data.iter().for_each(|el| println!("{}", el));
}
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);
    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);
}

Rocky.C

cloki0610

a month ago

398.28ms

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 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 reference = Rc::new(items);
    take_item(reference.clone());
    take_item(reference.clone());
    take_item(reference.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);
}

slaws

a month ago

381.11ms

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 d in &*data {
        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 reference = Rc::new(items);
    take_item(reference.clone());
    take_item(reference.clone());
    take_item(reference.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);
}

Baron Curtin

baroncurtin2

a month ago

404.48ms

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 = Rc::new(items);
    for _ in 0..3 {
        take_item(shared.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);
}

Marco-Normal

a month ago

370.89ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T: std::fmt::Display>(data: Rc<Vec<T>>) {
    for d in &*data {
        println!("{}", d);
    }
    // 1. Loop over each item in the vector and print it using `println!`
}
pub fn share_data_to_other_functions<F>(mut take_item: F, items: Vec<String>)
where
    F: FnMut(Rc<Vec<String>>),
{
       let reference = Rc::new(items);
    take_item(reference.clone());
    take_item(reference.clone());
    take_item(reference.clone());
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
}
// 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);
}

Evrins Hu

evrins

a month ago

377.80ms

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!`
    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>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    let reference = Rc::new(items);
    take_item(reference.clone());
    take_item(reference.clone());
    take_item(reference.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);
}

medzernik

a month ago

421.77ms

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>>),
{
    let shared = Rc::new(items);
    take_item(Rc::clone(&shared));
    take_item(Rc::clone(&shared));
    take_item(Rc::clone(&shared));
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
}
// 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);
}

johndoe30bc

a month ago

406.59ms

92.44kb

use std::{fmt::Display, rc::Rc};
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>>),
{
    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);
}

Procybit

a month ago

410.44ms

92.44kb

use std::{fmt::Display, rc::Rc};
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    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>>),
{
    let rc = Rc::new(items);
    for _ in 0..3 {
        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);
}

Cristian Prieto

cprieto

a month ago

406.64ms

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 items = Rc::new(items);
    take_item(items.clone());
    take_item(items.clone());
    // This clone is actually not needed, stupid bad exercise!
    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);
}

xxxxsk

a month ago

384.59ms

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(|item| {
        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 r = Rc::new(items);
    take_item(Rc::clone(&r));
    take_item(Rc::clone(&r));
    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);
}

FredoPo

a month ago

409.51ms

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(|val| println!("{}", val));
}
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_vector = Rc::new(items);
    take_item(Rc::clone(&rc_vector));
    take_item(Rc::clone(&rc_vector));
    take_item(Rc::clone(&rc_vector));
}
// 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);
}

Miguel Ángel Allende

maallende

a month ago

375.65ms

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!`
    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>>),
{
    // 2. Implement the function
    // Share the data as a reference-counted pointer 3 times with the closure
    // Share the input as a reference-counted pointer 3 times with the given closure.
    // Do cheap clones only and avoid deep copying the data.
    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);
}

Evgenii Grigorenko

grevgeny

a month ago

429.35ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T: std::fmt::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 items = Rc::new(items);
    take_item(Rc::clone(&items));
    take_item(Rc::clone(&items));
    take_item(Rc::clone(&items));
}
// Example usage
pub fn main() {
    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);
}

Evgenii Grigorenko

grevgeny

a month ago

386.34ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T: std::fmt::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 items = Rc::new(items);
    take_item(Rc::clone(&items));
    take_item(Rc::clone(&items));
    take_item(Rc::clone(&items));
}
// Example usage
pub fn main() {
    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);
}

brucecox01

2 months ago

395.18ms

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 x in &*data {
        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 items = Rc::new(items);
    for _ in 0..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);
}

Krzysztof Atłasik

katlasik

2 months ago

372.32ms

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

Tengz Mao

MaoX-Yu

2 months ago

395.69ms

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

Tengz Mao

MaoX-Yu

2 months ago

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

Philippe Massicotte

PMassicotte

2 months ago

368.47ms

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(|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..=2).for_each(|_| {
        // println!("Current ref count is: {}", Rc::strong_count(&rc));
        // Will always print 1, because the reference is dropped after the execution of take_item
        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));
    // This would work also
    // use_shared_data(shared_numbers.clone());
    // 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);
}

Enes

enesscevik

2 months ago

390.12ms

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

Ushakov Andrey

stdstring

2 months ago

417.05ms

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(|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);
    take_item(rc.clone());
    take_item(rc.clone());
    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);
}

0x0f1

Paul4673

2 months ago

383.15ms

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

vanos001

2 months ago

375.50ms

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(|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 p = Rc::new(items);
    take_item(Rc::clone(&p));
    take_item(Rc::clone(&p));
    take_item(Rc::clone(&p));
}
// 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);
}

alexsavio

2 months ago

393.57ms

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 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);
    take_item(Rc::clone(&rc_items));
    take_item(Rc::clone(&rc_items));
    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);
}

whhc

2 months ago

391.53ms

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(|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 rc_items = Rc::new(items);
    (0..=2).for_each(|_| take_item(rc_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);
}

ikatlinsky

2 months ago

397.46ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data<T: std::fmt::Display>(data: Rc<Vec<T>>) {
    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 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);
}

Seth Wood

seth-wood

2 months ago

401.10ms

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

diucicd

2 months ago

371.52ms

92.44kb

use std::{
    fmt::{Debug, Display},
    rc::Rc,
};
pub fn use_shared_data<T>(data: Rc<Vec<T>>)
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 p1 = Rc::new(items);
    take_item(p1.clone());
    take_item(p1.clone());
    take_item(p1.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);
}

Sergey Matyash

matiaspub

2 months ago

430.59ms

92.44kb

use std::{rc::Rc, 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!`
    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 shared = Rc::new(items);
    for _ in 0..3 {
        take_item(shared.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);
}

LeonardoPinheiro23

3 months ago

441.26ms

92.44kb

use std::{fmt::Display, rc::Rc};
pub fn use_shared_data<T: Display>(data: Rc<Vec<T>>) {
    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>>) {
    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);
}

Tommytto

3 months ago

416.20ms

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(|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 = Rc::new(items);
    for _ in 0..3 {
        take_item(shared.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);
}

sjmellor

3 months ago

392.87ms

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(|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 shared_items = Rc::new(items);
    take_item(shared_items.clone());
    take_item(shared_items.clone());
    take_item(shared_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);
}

Nicolai

Posmac

3 months ago

420.81ms

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!`
    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 = Rc::new(items);
    take_item(rc.clone());
    take_item(rc.clone());
    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);
}

ggnne

3 months ago

449.64ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data(data: Rc<Vec<impl std::fmt::Display>>) {
    // 1. Loop over each item in the vector and print it using `println!`
    for v in data.iter() {
        println!("{v}");
    }
}
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);
    for _ in 0..3 { 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);
}

Elizabeth Doughty

Thymelizabeth

3 months ago

392.22ms

92.44kb

use std::rc::Rc;
pub fn use_shared_data(data: Rc<Vec<impl std::fmt::Display>>) {
    // 1. Loop over each item in the vector and print it using `println!`
    for datum in data.iter() {
        println!("{}", datum);
    }
}
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 0..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);
}