An implementation of Nathaniel J. Smiths Structured Concurrency model: Notes on Structured Concurrency.
The building block of concurrency is called a Nursery. They can adopt or schedule
concurrent operations. Before a Nursery is dropped it will block on all of it's
pending concurrent operations. A Nursery is itself a concurrent operation so
it can be adopted by another Nursery to form a hierarchy.
```rust extern crate nursery; use nursery::thread::{Handle, Pending}; use nursery::{Nursery, Waitable}; use std::sync::Arc; use std::sync::Mutex;
pub struct Counter { count: i32, }
impl Counter { pub fn incr(&mut self) { self.count += 1; } }
let counter = Arc::new(Mutex::new(Counter { count: 0 })); { let hcounter = counter.clone(); let h1 = Pending::new(move || { let mut c = hcounter.lock().unwrap(); c.incr(); }); let hcounter = counter.clone(); let h2 = Pending::new(move || { let mut c = hcounter.lock().unwrap(); c.incr(); }); let mut child = Nursery::new(); child.schedule(Box::new(h1)); child.schedule(Box::new(h2)); let mut parent = Nursery::new(); parent.adopt(child.into()); // Before parent is dropped all of the above concurrent operations // will complete. } assert_eq!(counter.lock().unwrap().count, 2); ```