Struct Walk 

pub struct Walk<'a> { /* private fields */ }

A cursor over the members that only ever moves forward.

Intset::iter is enough to read a set out, and it is not enough to merge two of them, because a merge needs to skip. Intersecting a set of ten with a set of a million should touch ten members of the big one and not a million, and that is Walk::seek, which jumps to the first member at or past a value instead of stepping to it.

Forward only, and that is the whole reason it is worth having. A cursor that could go backwards would have to binary search the entire set on every seek. This one searches from where it already is, so a merge that walks two sets in lockstep pays one comparison a member in the common case and only searches when it actually skipped something.

Stepping is a pointer step and nothing else, which is what makes a merge a different order of cost from a probe. setops.rs explains what that buys and has the numbers.

Implementations

impl<'a> Walk<'a>

pub fn peek(&self) -> Option<i64>

The member the cursor is on, or None past the end.

pub fn bump(&mut self)

Move to the next member.

pub fn seek(&mut self, v: i64)

Move to the first member that is not under v, without going backwards.

A seek to a value the cursor is already at or past does nothing, which is what makes this safe to call in a loop that does not know whether it has moved.

Trait Implementations

impl<'a> Clone for Walk<'a>

fn clone(&self) -> Walk<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Walk<'a>

impl<'a> Debug for Walk<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.