Enum MapKey 

pub enum MapKey {
    Unit,
    Bool(bool),
    Int(i64),
    Duration(i64),
    Str(String),
    EnumCase(String, String, Vec<MapKey>),
    Struct(String, Vec<(String, MapKey)>, bool),
    Array(Vec<MapKey>),
    Set(BTreeSet<MapKey>),
    Map(BTreeMap<MapKey, MapKey>),
    Range {
        start: i64,
        end: i64,
        inclusive_end: bool,
    },
}

A value usable as a Map key or Set element.

ADR 0001 draws the line at mutability, not at primitives: “mutable handles and structs containing them are not valid map keys.” A key’s equality must not change while a collection holds it, so this is recursive rather than a flat list of primitive shapes — a Struct, an Array, or an enum case with a payload qualifies exactly when everything nested inside it does. Map and Set qualify too: both are immutable handles, so nesting one as a key changes nothing about the rule, only how deep the check goes. A Range qualifies for the same reason: it is an immutable value with a stable eq_value, ordered consistently by its (start, end, inclusive_end) fields. Float is rejected for an unrelated reason: NaN is not equal to itself, which breaks the total order every key needs.

Variants

Unit

Bool(bool)

Int(i64)

Duration(i64)

Str(String)

EnumCase(String, String, Vec<MapKey>)

An enum case, keyed by (type, case), with every payload value converted the same way.

Struct(String, Vec<(String, MapKey)>, bool)

A struct, keyed by type name, with every field converted the same way, in declaration order, and whether its type is opaque — a key is rendered back as a value for keys() and for Display, and a value of an opaque type shows only its name wherever it is read from.

Array(Vec<MapKey>)

An array, with every element converted the same way. An array is fixed-length and immutable, so its equality cannot change.

Set(BTreeSet<MapKey>)

A Set. Its elements are already MapKeys by construction, so nesting one never fails.

Map(BTreeMap<MapKey, MapKey>)

A Map. Its keys are already MapKeys by construction; only its values need converting, and the first one that cannot be is why nesting a Map as a key can still fail.

Range

A range. Immutable with a stable eq_value, so it qualifies under the same rule as every other key: its equality cannot change while a collection holds it. Ordered by (start, end, inclusive_end), which is a total order because every field is.

Fields

start: i64

end: i64

inclusive_end: bool

Implementations

impl MapKey

pub fn from_value(value: &Value) -> Result<MapKey, InvalidKey>

Converts value to a map key or set element, or reports the specific part that cannot be one, with the path to reach it.

pub fn to_value(&self) -> Value

Renders this key back as an ordinary value, for keys(), Set iteration, and toArray().

Trait Implementations

impl Clone for MapKey

fn clone(&self) -> MapKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MapKey

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

Formats the value using the given formatter.

impl Display for MapKey

A key displays exactly as the value it represents would, so a Map’s entries read the same way here as they would anywhere else in the language.

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

Formats the value using the given formatter.

impl Eq for MapKey

impl Ord for MapKey

fn cmp(&self, other: &MapKey) -> 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.

impl PartialEq for MapKey

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for MapKey

fn partial_cmp(&self, other: &MapKey) -> 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 MapKey