winterval 0.2.0

Interval adapter for both open/closed implementations of intervals ( ranges ).
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

<!-- {{# generate.module_header{} #}} -->

# Module :: winterval
[![experimental](https://raster.shields.io/static/v1?label=stability&message=experimental&color=orange&logoColor=eee)](https://github.com/emersion/stability-badges#experimental) [![rust-status](https://github.com/Wandalen/wTools/actions/workflows/ModulewIntervalPush.yml/badge.svg)](https://github.com/Wandalen/wTools/actions/workflows/ModulewIntervalPush.yml) [![docs.rs](https://img.shields.io/docsrs/winterval?color=e3e8f0&logo=docs.rs)](https://docs.rs/winterval) [![Open in Gitpod](https://raster.shields.io/static/v1?label=try&message=online&color=eee&logo=gitpod&logoColor=eee)](https://gitpod.io/#RUN_PATH=.,SAMPLE_FILE=sample%2Frust%2Fwinterval_trivial_sample%2Fsrc%2Fmain.rs,RUN_POSTFIX=--example%20winterval_trivial_sample/https://github.com/Wandalen/wTools) [![discord](https://img.shields.io/discord/872391416519737405?color=eee&logo=discord&logoColor=eee&label=ask)](https://discord.gg/m3YfbXpUUY)

Integer interval adapter for both Range and RangeInclusive.

Let's assume you have a function which should accept Interval. But you don't want to limit caller of the function to either half-open interval `core::ops::Range` or closed one `core::ops::RangeInclusive` you want allow to use anyone of iterable interval. To make that work smoothly use `IterableInterval`. Both `core::ops::Range` and `core::ops::RangeInclusive` implement the trait, also it's possible to work with non-iterable intervals, like ( -Infinity .. +Infinity ).

### Sample

Basic use-case.

```rust

use winterval::IterableInterval;

fn f1( interval : impl IterableInterval )
{
  for i in interval
  {
    println!( "{i}" );
  }
}

// Calling the function either with
// half-open interval `core::ops::Range`.
f1( 0..=3 );
// Or closed one `core::ops::RangeInclusive`.
f1( 0..4 );

```

### More flexibility

If you need more flexibility in defining intervals, you can convert a tuple of endpoints to an interval.

```rust

use winterval::{ IterableInterval, IntoInterval, Bound };

fn f1( interval : impl IterableInterval )
{
  for i in interval
  {
    println!( "{i}" );
  }
}

// Calling the function either with
// half-open interval `core::ops::Range`.
f1( 0..=3 );
// Or closed one `core::ops::RangeInclusive`.
f1( 0..4 );
// Alternatively you construct your custom interval from a tuple.
f1( ( 0, 3 ).into_interval() );
f1( ( Bound::Included( 0 ), Bound::Included( 3 ) ).into_interval() );
// All the calls to the function `f1`` perform the same task,
// and the output is exactly identical.

```

### Non-iterable intervals

You may also use the crate to specify non-iterable intervals. Non-iterable intervals have either one or several unbound endpoints. For example, interval `core::ops::RangeFull` has no bounds and represents the range from minus infinity to plus infinity.

```rust

use winterval::{ NonIterableInterval, IntoInterval, Bound };

fn f1( interval : impl NonIterableInterval )
{
  println!( "Do something with this {:?} .. {:?} interval", interval.left(), interval.right() );
}

// Iterable/bound interval from tuple.
f1( ( Bound::Included( 0 ), Bound::Included( 3 ) ).into_interval() );
// Non-iterable/unbound interval from tuple.
f1( ( Bound::Included( 0 ), Bound::Unbounded ).into_interval() );
// Non-iterable/unbound interval from `core::ops::RangeFrom`.
f1( 0.. );
// Non-iterable/unbound interval from `core::ops::RangeFull`
// what is ( -Infinity .. +Infinity ).
f1( .. );

```

### To add to your project

```sh
cargo add interval_adaptor
```

### Try out from the repository

```sh
git clone https://github.com/Wandalen/wTools
cd wTools
cargo run --example winterval_trivial
```
<!-- zzz : test that too -->