Enum Standing 

#[non_exhaustive]
pub enum Standing {
    Open,
    Taken,
    Inherited,
    Pruned,
    PrunedAbove,
}

Whether a FacetValue is narrowing the set, and how it came to be.

Five rather than a bool, and the extra members are what a tree costs. A pruned branch and an untaken one are not the same state (one was decided against and the other was never reached) and a child under a taken parent is in force without anybody having picked it. A renderer given a bool either marks every descendant of a taken branch, which reads as forty deliberate choices, or marks none of them, which reads as unfiltered.

The out side needs the same pair the in side has. A child under a pruned branch is out without anybody having pruned it: PrunedAbove to Pruned’s decision, as Inherited is to Taken’s.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Open

Not picked, and nothing above it is either.

Taken

Picked here. The set is narrowed to it and whatever hangs off it.

Inherited

In force because something above it was taken.

Pruned

Pruned out, though something above it was taken.

The state that only Selecting::Subtree can reach, and the reason exclusion is drawn as a visible affordance beside each label rather than as a modifier on the ordinary one: a gesture a terminal cannot express is a gesture half the renderers would have to leave out, and an affordance nothing teaches is one users do not find.

PrunedAbove

Out because something above it was pruned.

Not picked: clearing it clears nothing, because the decision is further up, which is Inherited’s position on the other side.

Implementations

impl Standing

pub const fn is_picked(self) -> bool

Whether the user decided this value, either way.

True for Taken and Pruned, both are choices, and both are things a “clear this” affordance has to clear. Inherited is not: clearing it clears nothing, because the decision is further up.

pub const fn in_force(self) -> bool

Whether the value narrows the set in.

Taken and Inherited: one was picked and one came down from above, and to the set they mean the same thing. The pair is named here so a renderer colouring in-force values does not have to know which is which.

pub const fn intent(self) -> &'static str

The content intent the value takes.

Pruned reads back a step, which is the three-tone rule above rather than a new decision: a pruned branch is still a live control (pressing it takes the prune off) so it may not wear content-muted, and it is not the thing itself either.

pub const fn pruned_out(self) -> bool

Whether the value is out of the set by a prune, here or above.

in_force’s counterpart, so a renderer reading a value back a step does not have to know which of the two it has.

Trait Implementations

impl Clone for Standing

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Standing

impl Debug for Standing

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

Formats the value using the given formatter.

impl Default for Standing

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Standing

impl From<Standing> for Standing

fn from(standing: Standing) -> Self

Converts to this type from the input type.

impl Hash for Standing

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Standing

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Standing