howlast 0.1.2

A procedural macro to easily misure computation times.
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

# howlast


`howlast` is a Rust procedural macro designed for timing code execution.
It provides an easy way to measure the duration of specific code blocks, helping developers optimize performance.

## Installation


To use `howlast`, add it as a dependency in your `Cargo.toml` file:

```toml
[dependencies]
howlast = "0.1.2"
```

Then, include the macro in your Rust code:

```rust
use howlast::howlast;
```

## Example Usage


Here's an example of how to use the `howlast` macro:

```rust
use howlast::howlast;

fn main() {
       howlast!(step_duration => {
        let x = 1 + 1;
        std::thread::sleep(std::time::Duration::from_secs(1));
        x
    });
    print!("{:?}", step_duration);

    howlast!(step_duration, result => {
        let x = 1 + 1;
        std::thread::sleep(std::time::Duration::from_secs(1));
        x
    });
    print!("{:?} {:?}", step_duration, result);

    howlast!(step_duration, result => 2+2);
    print!("{:?} {:?}", step_duration, result);
}
```

This will output the execution time of the code block along with the result of the computation.