#interval #range #fundamental #general-purpose #adapter #closed #open

no-std winterval

Interval adapter for both open/closed implementations of intervals ( ranges )

10 unstable releases (3 breaking)

0.3.0 Oct 28, 2023
0.2.3 Oct 17, 2023
0.1.5 Jun 12, 2022
0.1.3 May 26, 2022
0.0.1 Dec 21, 2021

#6 in #closed

Download history 3486/week @ 2024-03-13 2768/week @ 2024-03-20 577/week @ 2024-03-27 718/week @ 2024-04-03 531/week @ 2024-04-10 381/week @ 2024-04-17 658/week @ 2024-04-24 822/week @ 2024-05-01 1368/week @ 2024-05-08 840/week @ 2024-05-15 419/week @ 2024-05-22 1264/week @ 2024-05-29 515/week @ 2024-06-05 326/week @ 2024-06-12 187/week @ 2024-06-19 165/week @ 2024-06-26

1,308 downloads per month
Used in 32 crates (2 directly)

MIT license

29KB
517 lines

Module :: winterval

experimental rust-status docs.rs Open in Gitpod discord

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

Basic use-case.


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.


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.


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

cargo add interval_adaptor

Try out from the repository

git clone https://github.com/Wandalen/wTools
cd wTools
cargo run --example winterval_trivial

Dependencies