Struct Thunk 

pub struct Thunk<I>(/* private fields */);

惰性集合

可以进行惰性的二元逻辑运算，中间不计算、不分配内存，最后一次性迭代或收集。

通过 FlatBitSet::thunk 创建。

let s1 = FlatBitSet::<usize>::from_iter([1, 2, 3]);
let s2 = FlatBitSet::<usize>::from_iter([2, 3, 4]);
let s3 = FlatBitSet::<usize>::from_iter([3, 4, 5]);
let thunk = (s1.thunk() ^ s2.thunk()) | (s1.thunk() & s3.thunk());
assert!(thunk.clone().into_iter().eq([1, 3, 4]));
assert_eq!(thunk.collect(), FlatBitSet::<usize>::from_iter([1, 3, 4]));

Implementations

impl<I, K, C> Thunk<I>

where I: Iterator<Item = (K, C)>, K: Key, C: Chunk,

pub fn perform_biop<O, I2>(self, other: Thunk<I2>) -> Thunk<BiOpIter<O, I, I2>>

where O: BiOp<C>, I2: Iterator<Item = (K, C)>,

进行惰性二元运算

请使用 Thunk::intersection 之类的方法。 也可以使用 t1 & t2 之类的运算符，作用相同，更为简洁。

pub fn collect(self) -> FlatBitSet<K, C>

where I: Clone,

转换为 FlatBitSet

会预先计算大小，最多只会分配一次。

let s1 = FlatBitSet::<usize>::from_iter([1, 2, 3]);
let s2 = FlatBitSet::<usize>::from_iter([2, 3, 4]);
let thunk = s1.thunk() ^ s2.thunk();
assert_eq!(thunk.collect(), FlatBitSet::<usize>::from_iter([1, 4]));

impl<I, K, C> Thunk<I>

where I: Iterator<Item = (K, C)>, K: Key, C: Chunk,

pub fn intersection<I2: Iterator<Item = (K, C)>>( self, other: Thunk<I2>, ) -> Thunk<BiOpIter<AndOp, I, I2>>

惰性计算交集

可以使用运算符 t1 & t2，作用相同，更为简洁。

let s1 = FlatBitSet::<usize>::from_iter([1, 2, 3]);
let s2 = FlatBitSet::<usize>::from_iter([2, 3, 4]);
let thunk = s1.thunk().intersection(s2.thunk());
assert!(thunk.into_iter().eq([2, 3]));

可以看看返回新集合的 FlatBitSet::intersection、就地计算的 FlatBitSet::intersection_with 以及返回迭代器的 FlatBitSet::intersection_iter。

impl<I, K, C> Thunk<I>

where I: Iterator<Item = (K, C)>, K: Key, C: Chunk,

pub fn union<I2: Iterator<Item = (K, C)>>( self, other: Thunk<I2>, ) -> Thunk<BiOpIter<OrOp, I, I2>>

惰性计算并集

可以使用运算符 t1 | t2，作用相同，更为简洁。

let s1 = FlatBitSet::<usize>::from_iter([1, 2, 3]);
let s2 = FlatBitSet::<usize>::from_iter([2, 3, 4]);
let thunk = s1.thunk().union(s2.thunk());
assert!(thunk.into_iter().eq([1, 2, 3, 4]));

可以看看返回新集合的 FlatBitSet::union、就地计算的 FlatBitSet::union_with 以及返回迭代器的 FlatBitSet::union_iter。

impl<I, K, C> Thunk<I>

where I: Iterator<Item = (K, C)>, K: Key, C: Chunk,

pub fn symmetric_difference<I2: Iterator<Item = (K, C)>>( self, other: Thunk<I2>, ) -> Thunk<BiOpIter<XorOp, I, I2>>

惰性计算对称差

可以使用运算符 t1 ^ t2，作用相同，更为简洁。

let s1 = FlatBitSet::<usize>::from_iter([1, 2, 3]);
let s2 = FlatBitSet::<usize>::from_iter([2, 3, 4]);
let thunk = s1.thunk().symmetric_difference(s2.thunk());
assert!(thunk.into_iter().eq([1, 4]));

可以看看返回新集合的 FlatBitSet::symmetric_difference、就地计算的 FlatBitSet::symmetric_difference_with 以及返回迭代器的 FlatBitSet::symmetric_difference_iter。

impl<I, K, C> Thunk<I>

where I: Iterator<Item = (K, C)>, K: Key, C: Chunk,

pub fn difference<I2: Iterator<Item = (K, C)>>( self, other: Thunk<I2>, ) -> Thunk<BiOpIter<DiffOp, I, I2>>

惰性计算差集

可以使用运算符 t1 - t2，作用相同，更为简洁。

let s1 = FlatBitSet::<usize>::from_iter([1, 2, 3]);
let s2 = FlatBitSet::<usize>::from_iter([2, 3, 4]);
let thunk = s1.thunk().difference(s2.thunk());
assert!(thunk.into_iter().eq([1]));

可以看看返回新集合的 FlatBitSet::difference、就地计算的 FlatBitSet::difference_with 以及返回迭代器的 FlatBitSet::difference_iter。

Trait Implementations

impl<I, I2, K, C> BitAnd<Thunk<I2>> for Thunk<I>

where I: Iterator<Item = (K, C)>, I2: Iterator<Item = (K, C)>, K: Key, C: Chunk,

type Output = Thunk<BiOpIter<AndOp, I, I2>>

The resulting type after applying the & operator.

fn bitand(self, rhs: Thunk<I2>) -> Self::Output

Performs the & operation.

impl<I, I2, K, C> BitOr<Thunk<I2>> for Thunk<I>

where I: Iterator<Item = (K, C)>, I2: Iterator<Item = (K, C)>, K: Key, C: Chunk,

type Output = Thunk<BiOpIter<OrOp, I, I2>>

The resulting type after applying the | operator.

fn bitor(self, rhs: Thunk<I2>) -> Self::Output

Performs the | operation.

impl<I, I2, K, C> BitXor<Thunk<I2>> for Thunk<I>

where I: Iterator<Item = (K, C)>, I2: Iterator<Item = (K, C)>, K: Key, C: Chunk,

type Output = Thunk<BiOpIter<XorOp, I, I2>>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Thunk<I2>) -> Self::Output

Performs the ^ operation.

impl<I: Clone> Clone for Thunk<I>

fn clone(&self) -> Thunk<I>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I, K, C> IntoIterator for Thunk<I>

where I: Iterator<Item = (K, C)>, K: Key, C: Chunk,

type Item = K

The type of the elements being iterated over.

type IntoIter = GenericIter<I, K, C>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<I, I2, K, C> Sub<Thunk<I2>> for Thunk<I>

where I: Iterator<Item = (K, C)>, I2: Iterator<Item = (K, C)>, K: Key, C: Chunk,

type Output = Thunk<BiOpIter<DiffOp, I, I2>>

The resulting type after applying the - operator.

fn sub(self, rhs: Thunk<I2>) -> Self::Output

Performs the - operation.