disuse 0.0.1

The way to notify the implementation which return value is disuse.
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

# disuse
## Description
The way to notify the implementation which return value is disuse.
## Usage
When an algorithm can calculate multiple useful values simultaneously, you will write like the following code.
```rust
pub fn some_algorithm(x: f64) -> (f64, f64, f64) {
    let mut r1 = 0f64; let mut r2 = 0f64; let mut r3 = 0f64;

    for _ in 0..1000 { // ... some eavy calculations here ...
        r1 += x;
        r2 += x * 2.0;
        r3 += x * 3.0;
    }
    (r1, r2, r3)
}
```
But your users are not always need all return values.
```rust
# pub fn some_algorithm(x: f64) -> (f64, f64, f64) {
#    let mut r1 = 0f64; let mut r2 = 0f64; let mut r3 = 0f64;
#
#    for _ in 0..1000 { // ... heavy calculations here ...
#        r1 += x;
#        r2 += x * 2.0;
#        r3 += x * 3.0;
#    }
#    (r1, r2, r3)
# }
// Yes, we can ignore the return values, but calculations done.
let (a, _, _) = some_algorithm(4.0);
```
Above example code can be rewrite using [Disuse] as follows,
```rust
use disuse::Disuse;

pub fn some_algorithm<R1, R2, R3>(x: f64) -> (R1, R2, R3)
where
    R1: From<(f64,)>, R2: From<(f64,)>, R3: From<(f64,)>
{
   let mut r1 = 0f64; let mut r2 = 0f64; let mut r3 = 0f64;

   for _ in 0..1000 { // ... heavy calculations here ...
       r1 += x;
       r2 += x * 2.0; // When user call this function like below,
       r3 += x * 3.0; // we can expect the compiler eliminate this two line, right?
   }
   ((r1,).into(), (r2,).into(), (r3,).into())
}

let ((a,), _, _): ((f64,), Disuse, Disuse) = some_algorithm(4.0);
```
Oops, just a little ugly...(a little?)

If the unit type ([()](unit)) implements [From] trait like as follows,
```rust
impl<T> From<T> for () {
    fn from(_: T) -> () { () }
}
```
above example code can be write more smart.
```rust
pub fn some_algorithm<R1, R2, R3>(x: f64) -> (R1, R2, R3)
where
    R1: From<f64>, R2: From<f64>, R3: From<f64>
{
   let mut r1 = 0f64; let mut r2 = 0f64; let mut r3 = 0f64;

   for _ in 0..1000 { // ... heavy calculations here ...
       r1 += x;
       r2 += x * 2.0; // When user call this function like below,
       r3 += x * 3.0; // we can expect the compiler eliminate this two line, right?
   }
   (r1.into(), r2.into(), r3.into())
}

let (a, _, _): (f64, (), ()) = some_algorithm(4.0);
```
It's just unrealizable dream...