use super::Node;
pub type Stream<T> = Box<dyn Iterator<Item = T>>;
pub type NodeStream = Stream<Node>;
pub fn lazy<T, I, F>(make: F) -> Stream<T>
where
T: 'static,
I: IntoIterator<Item = T>,
I::IntoIter: 'static,
F: FnOnce() -> I + 'static,
{
Box::new(Lazy {
make: Some(make),
iter: None,
})
}
pub fn from_vec<T: 'static>(elements: Vec<T>) -> Stream<T> {
Box::new(elements.into_iter())
}
pub fn empty<T: 'static>() -> Stream<T> {
Box::new(std::iter::empty())
}
struct Lazy<F, I> {
make: Option<F>,
iter: Option<I>,
}
impl<T, I, F> Iterator for Lazy<F, I::IntoIter>
where
I: IntoIterator<Item = T>,
F: FnOnce() -> I,
{
type Item = T;
fn next(&mut self) -> Option<T> {
if let Some(make) = self.make.take() {
self.iter = Some(make().into_iter());
}
self.iter.as_mut()?.next()
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::cell::Cell;
use std::rc::Rc;
#[test]
fn lazy_runs_on_the_first_next() {
let ran = Rc::new(Cell::new(false));
let r = ran.clone();
let mut s = lazy(move || {
r.set(true);
vec![1, 2]
});
assert!(!ran.get());
assert_eq!(s.next(), Some(1));
assert!(ran.get());
assert_eq!(s.collect::<Vec<_>>(), vec![2]);
}
}