ZipperMoving

Some zippers allow the focus to be moved, which is done using the methods in the ZipperMoving trait. It is almost always faster to move a zipper's focus than to create a new zipper. Moving to a longer path is called descending while moving to a shorter path is called ascending.

The ZipperMoving trait provides methods to navigate through the trie. It provides both fine-grained single-step movement and higher-level jumping methods.

Descending is not limited in any way, and moving the focus to non-existent paths is one of the ways new paths are created by zippers with writing capability. When ascending, the zipper's focus cannot be moved above the zipper's root. The root is the highest possible position for the zipper's focus.

Reset and the Root Position

• reset moves the focus back to the zipper's root.
• at_root checks if the zipper is at its root position.

Absolute Positioning

• move_to_path moves the zipper's focus directly to a specific path relative to the zipper's root.

Stepping vs. Jumping

Zippers may be descended and ascended either by stepping an absolute number of elements, or by jumping to features such as branches, values, or the end of the path. In general, moving by jumping will be faster than stepping.

Stepping Methods

These methods move the zipper by specific byte distances

• descend_to_byte descends down one level to the specified child byte
• descend_indexed_byte descends one byte to the nth child branch (by index in the child mask)
• descend_first_byte moves down to the first child branch
• ascend moves up a specified number of bytes toward the root
• ascend_byte moves up exactly one byte (equivalent to ascend(1))

Jumping Methods

These methods move the zipper to positions based on trie features:

• descend_to moves to a path relative to the current focus position
• descend_to_existing follows a path, stopping if a non-existent path byte is encountered
• descend_to_val similar to descend_to_existing but also stops if a value is encountered
• descend_until descends until a position with multiple children or a value is encountered
• ascend_until ascends until reaching a position with multiple children, a value, or the root
• ascend_until_branch ascends until reaching a position with multiple children, skipping values

Sibling Navigation

• to_next_sibling_byte moves to the next sibling at the current level
• to_prev_sibling_byte moves to the previous sibling at the current level