disuse

Crates.iodisuse
lib.rsdisuse
version0.0.2
sourcesrc
created_at2021-12-25 06:42:41.977712
updated_at2022-03-04 13:17:37.621391
descriptionThe way to notify the implementation which return value is disuse.
homepagehttps://gitlab.com/fton/disuse
repositoryhttps://gitlab.com/fton/disuse
max_upload_size
id502877
size5,601
(fton)

documentation

README

Latest Release pipeline status coverage report

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.

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 heavy 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.
// Yes, we can ignore the return values, but calculations done.

let (a, _, _) = some_algorithm(4.0);

Above example code can be rewritten using Disuse as follows,

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);

It's better than before version.

(But return type should implement Clone trait.)

If the unit type (()(unit)) implemented From trait like as follows,

impl<T> From<T> for () {
    fn from(_: T) -> () { () }
}

above example code could be written more smart.

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...

Commit count: 16

cargo fmt