# `task-group`
A small crate for managing groups of tokio tasks.
```rust
let (task_group, task_manager): (TaskGroup<Error>, TaskManager<_>) = TaskGroup::new();
task_group.clone().spawn("a task", async move {
task_group.spawn("b task", async move {
/* all kinds of things */
Ok(())
}).await.expect("spawned b");
Ok(())
}).await.expect("spawned a");
task_manager.await.expect("everyone successful");
```
A `TaskGroup` is used to spawn a collection of tasks. The collection has two
properties:
* if any task returns an error or panicks, all tasks are terminated.
* if the `TaskManager` returned by `TaskGroup::new` is dropped, all tasks are
terminated.
A `TaskManager` is used to manage a collection of tasks. There are two
things you can do with it:
* TaskManager impls Future, so you can poll or await on it. It will be
Ready when all tasks return Ok(()) and the associated `TaskGroup` is
dropped (so no more tasks can be created), or when any task panicks or
returns an Err(E).
* When a TaskManager is dropped, all tasks it contains are canceled
(terminated). So, if you use a combinator like
`tokio::time::timeout(duration, task_manager).await`, all tasks will be
terminated if the timeout occurs.
See `examples/` and the tests in `src/lib.rs` for more examples.