lazy_list

这是一个Rust包，提供懒加载数据列表，可以是有限的或无限的。

有关使用信息，请参阅文档。

lib.rs:

该包提供了LazyList，一个可能无限的懒加载数据列表。

LazyList<T, I>可以像Vec<T>一样索引和修改其元素。然而，元素由类型为I的潜在无限迭代器按需生成，该迭代器在创建LazyList时指定。一旦生成元素，它将被缓存以供后续访问。

如果您不想指定迭代器类型作为类型参数，可以使用LazyListBoxed或LazyListOwned类型别名。

LazyList目前是不可变的，与协变相反，如果您在意这一点。

不可变的LazyList是线程安全的。

内部，LazyList将元素存储在64个元素的块中。这样我们就可以分配元素引用，而不会在缓存中添加更多元素时使它们失效。

示例

基本用法

use lazy_list::LazyList;

// Finite list
let list: LazyList<i32, _> = LazyList::new(0..100);
assert_eq!(list.into_iter().sum::<i32>(), 4950);
// Infinite list
let list: LazyList<i32, _>  = LazyList::new(0..);
assert_eq!(list.into_iter().take(100).sum::<i32>(), 4950);

修改LazyList

use lazy_list::LazyList;

let mut list = LazyList::new(0..);
assert_eq!(
    list.iter().take(10).copied().collect::<Vec<_>>(),
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
);
list[3] = 100;
assert_eq!(
    list.iter().take(10).copied().collect::<Vec<_>>(),
    [0, 1, 2, 100, 4, 5, 6, 7, 8, 9]
);

重用静态LazyList

use lazy_list::{LazyList, LazyListOwned, IteratorLazyExt};
use once_cell::sync::Lazy;

// Note that each element will only ever be produced once.
static EVENS: Lazy<LazyListOwned<i32>> =
    Lazy::new(|| (0..).map(|x| x * 2).collect_lazy().boxed());

fn evens_with_property(mut predicate: impl FnMut(i32) -> bool) -> impl Iterator<Item = i32> {
    EVENS.iter().copied().filter(move |&x| predicate(x))
}

assert_eq!(
    evens_with_property(|x| x % 3 == 0)
        .take(5)
        .collect::<Vec<_>>(),
    [0, 6, 12, 18, 24]
);
assert_eq!(
    evens_with_property(|x| x % 5 == 0)
        .take(5)
        .collect::<Vec<_>>(),
    [0, 10, 20, 30, 40]
);

递归LazyList

use lazy_list::{LazyList, LazyListBoxed};
use std::sync::Arc;

let fibonacci: Arc<LazyListBoxed<i32>> = LazyList::recursive(|fibonacci_ref, i| {
    if i < 2 {
        Some(1)
    } else {
        Some(fibonacci_ref[i - 1] + fibonacci_ref[i - 2])
    }
});
assert_eq!(
    fibonacci.iter().take(10).copied().collect::<Vec<_>>(),
    [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
);