Struct Nesting 

#[non_exhaustive]
pub struct Nesting {
    pub level: u8,
}

How deep a row sits inside a set: a tree, an outline, a threaded list.

RowPart below already names what is in a row; nothing named where a row sits relative to its siblings, so every consumer that had a hierarchy carried a bare number and every renderer decided for itself what one was worth.

Not Depth, and the collision is the reason

Depth is taken and means something else entirely: surface bevel – Flat, Raised, Well, Sunken, Overlay – a fact about a surface rather than a position in a hierarchy. Two meanings under one word in one crate is the collision that costs a reader an hour, and the word this concept wants is the one that would cause it.

The magnitude is the renderer’s, and that is the precedent

Awaiting is the shape: this crate names the fact and declines to name what it is worth. makeover-webview writes the rule as a custom property with a fallback – the way it writes margin-inline-start: var(--awaiting-gap, 0.5ch) – so a level has one answer per renderer and an app can override it. A terminal spends columns, a browser spends inline space, and neither number belongs in a description.

Zero is a real answer

top is the default and is what a flat list says: every row is at the top level, which is true and is the reading a renderer needs. An Option here would make “not nested” and “nested at zero” two spellings of one thing, the same argument Discovery’s indexable makes about defaults that are meaningful.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

level: u8

How many levels in, counting from zero.

u8 because a hierarchy a reader can follow is not 256 deep, and a renderer indenting by a level has to multiply it by something – a wider integer here is a wider integer in every renderer’s arithmetic for a range nothing will use.

Implementations

impl Nesting

pub const fn top() -> Self

The top level: not nested. The default, and what a flat list says.

pub const fn at(level: u8) -> Self

A row this many levels in.

pub const fn is_nested(self) -> bool

Whether this row sits under another.

The question every renderer asks before it spends anything on indenting, answered once here rather than by a > 0 in each – which is Awaiting::is_determinate’s reason too.

Trait Implementations

impl Clone for Nesting

fn clone(&self) -> Nesting

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Nesting

impl Debug for Nesting

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

Formats the value using the given formatter.

impl Default for Nesting

fn default() -> Nesting

Returns the “default value” for a type.

impl Eq for Nesting

impl Hash for Nesting

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 Ord for Nesting

fn cmp(&self, other: &Nesting) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Nesting

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Nesting

fn partial_cmp(&self, other: &Nesting) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Nesting