borrow-bag 0.1.0

A type-safe, heterogeneous collection with zero-cost add and borrow
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

# borrow-bag

A type-safe, heterogeneous collection with zero-cost add and borrow.

`BorrowBag` allows the storage of any value, and returns a `Handle` which can be
used to borrow the value back later. As the `BorrowBag` is add-only, `Handle`
values remain valid for the lifetime of the `BorrowBag`.

For usage details, please see the [documentation](https://docs.rs/borrow-bag/)

## Motivation

Initially, `BorrowBag` was conceived to solve the problem of storing concrete
types implementing a certain trait, without losing their type information, and
with an ability to borrow them back later.

The original implementation was generic enough that it was immediately extracted
into this crate.

## Use cases

Please create an issue or pull request so your use case can be added here.

## Example

```rust
extern crate borrow_bag;

use borrow_bag::new_borrow_bag;

struct X(u8);
struct Y(u8);

fn main() {
    let bag = new_borrow_bag();
    let (bag, x_handle) = bag.add(X(1));
    let (bag, y_handle) = bag.add(Y(2));

    let x: &X = bag.borrow(x_handle);
    assert_eq!(x.0, 1);
    let y: &Y = bag.borrow(y_handle);
    assert_eq!(y.0, 2);
}
```

## Contributing

### Bug reports and feature requests

Issues welcome.

### Development

Contributions welcome via pull request.

### Requested contributions

* Code review
* Feedback and/or criticism on the use of types
* Further validation that this is in fact "zero-cost" (when optimised)

## License

[MIT](https://opensource.org/licenses/MIT)