# Relevant

A small utility type to emulate must-use types.
They are different from `#[must_use]` attribute in that the one who have an instance must either send it somewhere else or `dispose` it manually.

This must be desired for types that need manual destruction which can't be implemented with `Drop` trait.
For example resource handler created from some source and that must be returned to the same source.

## Usage

The type `Relevant` is non-droppable. As limitation of current implementation it panics when dropped.
To make type non-droppable it must contain non-droppable type (`Relevant` type for example).

### Example

```rust

struct SourceOfFoos {
    handle: u64,
}

/// Foo must be destroyed manually.
struct Foo {
   handle: u64,
   relevant: Relevant,
}

/// Function from C library to create `Foo`
/// Access to same source must be synchronized.
extern "C" create_foo(source: u64) -> u64;

/// Function from C library to destroy `Foo`.
/// Access to same source must be synchronized.
extern "C" destroy_foo(source: u64, foo: u64) -> u64;

impl SourceOfFoos {
    fn create_foo(&mut self) -> Foo {
        Foo {
            handle: create_foo(self.handle),
            relevant: Relevant,
        }
    }

    fn destroy_foo(&mut self, foo: Foo) {
        destroy_foo(self.handle, foo.handle);
        foo.relevant.dispose();
    }
}

```

Now it is not possible to accidentally drop `Foo` and leak handle.
Of course it always possible to explicitly `std::mem::forget` relevant type.
But it will be deliberate leak.