Enum MarkKind 

#[non_exhaustive]
pub enum MarkKind {
    Strong,
    Emph,
    Underline,
    Strike,
    Code,
    Link {
        url: String,
    },
    Anchor {
        id: String,
    },
    Unknown {
        tag: String,
        attrs: Value,
    },
}

The mark set, open: an unknown kind round-trips as MarkKind::Unknown, absorbed as a new type, never a changed semantics of a known one. Two algebra classes: formatting is a property of a range (two coincident are redundant); identity is a handle (two over the same range are two things).

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.

Strong

Emph

Underline

Strike

Code

Link

Fields

url: String

Anchor

A comment thread or stable anchor, carried by id and rebased across edits like any position. The id is caller-supplied, unique per Content, opaque and invariant while the mark lives; positions rebase, the id never does, and moved-and-rewritten text drops the mark whole (DOCUMENT_STORAGE.md § Anchor-id identity). No markdown projection (omitted on export; survives via diff-rebase).

Fields

id: String

Unknown

Fields

tag: String

attrs: Value

Implementations

impl MarkKind

pub fn is_formatting(&self) -> bool

Formatting marks are a property of a range and union when coincident; identity/unknown marks are handles and never merge (Spike-A rules).

Class membership is stored meaning, not presentation: promoting an open-set tag into this class starts unioning adjacent runs that round-tripped as two marks, so the promotion moves the canonical bytes of documents nobody edited (DOCUMENT_STORAGE.md § Promoting a vocabulary member).

pub fn ord(&self) -> u8

Total order over kinds for the canonical sort tie-break, after (start, end). Stable across releases: part of the freeze.

A new variant takes the slot immediately before MarkKind::Unknown, pushing Unknown up by one. That is the only placement where a build that knows the type and a build that reads it as Unknown order it identically against every built-in; anywhere else is two canonical forms for one document, one per reader (DOCUMENT_STORAGE.md § Promoting a vocabulary member). The block axes sort by nothing, so the rule is the mark axis’ alone.

pub fn attrs_key(&self) -> String

Attribute tie-break string, appended after ord in the canonical sort so two marks that differ only in attrs order deterministically. Also the grouping key for same-kind union (two formatting marks union only when this matches; e.g. two links union only at the same url).

Trait Implementations

impl Clone for MarkKind

fn clone(&self) -> MarkKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MarkKind

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

Formats the value using the given formatter.

impl PartialEq for MarkKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for MarkKind