Struct OrderedMap 

pub struct OrderedMap { /* private fields */ }

remove shifts later entries down. Lookups are linear; that is the intended trade for small maps and stable ordering.

PartialEq is hand-written, not derived (issue #909, ruled 2026-07-18 — docs/decision-log.md “Map/record equality is insertion-order-insensitive”): equality is content-based, comparing key→value pairs regardless of insertion order — #{a:1,b:2} == #{b:2,a:1} is true. Only equality ignores order; iter/keys/values and every codec still walk entries in insertion order, unchanged. The derived PartialEq this replaces compared entries as a Vec, which is order-sensitive — the bug. Value::Map’s Arc::ptr_eq fast path (same snapshot → instant true) lives one level up in impl PartialEq for Value; this impl is the structural fallback it calls into.

Implementations

impl OrderedMap

pub fn new() -> Self

Create an empty map.

pub fn with_capacity(n: usize) -> Self

Create an empty map with capacity for n entries.

pub fn len(&self) -> usize

Number of entries.

pub fn is_empty(&self) -> bool

Whether the map has no entries.

pub fn get(&self, key: &MapKey) -> Option<&Value>

Borrow the value for key, or None if absent.

pub fn contains_key(&self, key: &MapKey) -> bool

Whether key is present.

pub fn get_mut(&mut self, key: &MapKey) -> Option<&mut Value>

Mutably borrow the value for key, or None if absent. The intermediate-segment leg of the T1e projection RMW spine (docs/t1e-spec.md §3): recursing a make_mut chain through a map needs a mutable handle to an existing entry without touching insertion order, which insert alone (add-or-replace) can’t provide.

pub fn insert(&mut self, key: MapKey, value: Value) -> Option<Value>

Insert value under key, returning the previous value if the key was already present.

An existing key keeps its insertion position (only its value changes); a new key is appended, so first-insertion order is preserved.

pub fn remove(&mut self, key: &MapKey) -> Option<Value>

Remove key, returning its value if it was present. Later entries shift down, so insertion order among the survivors is preserved.

pub fn iter(&self) -> impl Iterator<Item = (&MapKey, &Value)>

Iterate (key, value) pairs in insertion order.

pub fn keys(&self) -> impl Iterator<Item = &MapKey>

Iterate keys in insertion order.

pub fn values(&self) -> impl Iterator<Item = &Value>

Iterate values in insertion order.

Trait Implementations

impl Clone for OrderedMap

fn clone(&self) -> OrderedMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OrderedMap

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

Formats the value using the given formatter.

impl Default for OrderedMap

fn default() -> OrderedMap

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OrderedMap

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Hand-written, not derived (issue #985, follow-up to #909): the derived impl would deserialize entries verbatim as a Vec<(MapKey, Value)>, letting a crafted or corrupt payload carry a duplicate key and construct a map that violates the content-based Eq invariant above — Eq assumes each key appears at most once. This decodes into the same shape the derive would have produced, then walks the entries through the same duplicate-key check the .inkb/.inkt/transcript decoders use (rejecting rather than silently keeping the last occurrence — a legitimate encoder never emits a repeat, since insert de-duplicates on the write side, so a repeat is corrupt input, never a panic).

impl FromIterator<(MapKey, Value)> for OrderedMap

fn from_iter<I: IntoIterator<Item = (MapKey, Value)>>(iter: I) -> Self

Collect entries in order. If a key repeats, the last value wins while the key keeps its first-insertion position — matching insert.

impl PartialEq for OrderedMap

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

Content comparison: same number of entries, and every key in self maps to an equal value in other. Order-insensitive by construction (a lookup by key, not a positional walk) — the len check is a fast path (mismatched sizes can never be equal, and it makes the same-length-different-keys case cheap to reject), and the per-entry get gives each comparison the same Value::eq Arc::ptr_eq shortcuts as any other structural compare. O(n) entries, each a linear get — O(n^2) worst case, the accepted trade for small, game-scale maps (same trade get/insert/remove already make).

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

Inequality operator !=.

impl Serialize for OrderedMap

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.