A nicer way to create an ad hoc iterator than "vec![a,b,c].into_iter()"?

The expression vec![a, b, c].into_iter() seems unnecessarily long.Is there something better?

The doc for itertools kmerge gives this example:

use itertools::Itertools;
let a = (0..6).step(3);
let b = (1..6).step(3);
let c = (2..6).step(3);
let it = vec![a, b, c].into_iter().kmerge();
itertools::assert_equal(it, vec![0, 1, 2, 3, 4, 5]);

When you just want to create an ad hoc iterator of values, is there anything better?
Maybe something like iter![a,b,c] (if iter is taken, then some other word).
If this is possible, I've got to believe that someone's already done it, but I can't find anything.

An array works just as well as a Vec and avoids the heap allocation.

[a, b, c].into_iter()

Perhaps the documentation predates Rust 1.53 when this was stabilized.

Thanks for all the help! Putting it all together, we can make [a, b, c].kmerge() work:

    use itertools::Itertools;
    let a = (0..6).step_by(3);
    let b = (1..6).step_by(3);
    let c = (2..6).step_by(3);
    let it = [a, b, c].kmerge();
    itertools::assert_equal(it, [0, 1, 2, 3, 4, 5]);

The extra step is to extend all IntoIterator's:

use itertools::kmerge;
use itertools::KMerge;
impl<I: IntoIterator> IntoItertoolsPlus for I {}
pub trait IntoItertoolsPlus: IntoIterator {
    fn kmerge(self) -> KMerge<<Self::Item as IntoIterator>::IntoIter>
    where
        Self: IntoIterator + Sized,
        Self::Item: IntoIterator,
        <<Self as IntoIterator>::Item as IntoIterator>::Item: PartialOrd,
    {
        kmerge(self)
    }
}

I'm going to use this method for two of my own functions. They both accept a variable number of same-type inputs.