iter_vals

This crate allows for on the fly iterator creation.

Examples

You can use it to return an iterator over literals:

```rust use itervals::itervals;

[derive(Debug, PartialEq)]

enum Media { Book, Newspaper, TV, PC, }

use Media::*;

impl Media { fn digital() -> impl Iterator { iter_vals!(TV, PC) }

fn non_digital() -> impl Iterator<Item = Media> {
    iter_vals!(Book, Newspaper)
}

}

let mut digital = Media::digital(); asserteq!(digital.next(), Some(TV)); asserteq!(digital.next(), Some(PC)); assert_eq!(digital.next(), None);

let mut nondigital = Media::nondigital(); asserteq!(nondigital.next(), Some(Book)); asserteq!(nondigital.next(), Some(Newspaper)); asserteq!(nondigital.next(), None); ```

You can conditionally include values. This can be useful to return a variable number of values without having to allocate:

```rust use itervals::itervals;

fn nextnumbers(start: i32, includefirstnumber: bool) -> impl Iterator { itervals!( [..= includefirstnumber; start + 1], (start + 2), (start + 3) ) }

let mut nextnums = nextnumbers(5, true); asserteq!(nextnums.next(), Some(6)); asserteq!(nextnums.next(), Some(7)); asserteq!(nextnums.next(), Some(8)); asserteq!(nextnums.next(), None);

let mut nextnums = nextnumbers(5, false); asserteq!(nextnums.next(), Some(7)); asserteq!(nextnums.next(), Some(8)); asserteq!(nextnums.next(), None); ```

You can expand other iterators inside the iterator you return. This can be especially useful, when dealing with Options:

```rust use itervals::itervals;

fn makeiter(num1: i32, num2: Option, num3: i32) -> impl Iterator { itervals!( num1, [.. num2], num3 ) }

let mut nums = makeiter(1, Some(2), 3); asserteq!(nums.next(), Some(1)); asserteq!(nums.next(), Some(2)); asserteq!(nums.next(), Some(3)); assert_eq!(nums.next(), None);

let mut nums = makeiter(1, None, 3); asserteq!(nums.next(), Some(1)); asserteq!(nums.next(), Some(3)); asserteq!(nums.next(), None);

let mut nums = itervals!(1, [.. vec![2, 2]], 3); asserteq!(nums.next(), Some(1)); asserteq!(nums.next(), Some(2)); asserteq!(nums.next(), Some(2)); asserteq!(nums.next(), Some(3)); asserteq!(nums.next(), None); ```

Note

If you want to return computed values, you currently have to put them in parenthesis for that to work, because of a limitation in the macro system.

This will not work:

```nocompile use itervals::iter_vals;

let nums: Vec<_> = itervals!(1 + 1, 2 + 2, 3 + 3).collect(); asserteq!(nums, vec![2, 4, 6]); ```

But this will:

```rust use itervals::itervals;

let nums: Vec<_> = itervals!((1 + 1), (2 + 2), (3 + 3)).collect(); asserteq!(nums, vec![2, 4, 6]); ```