Enum UnsupportedReason 

#[non_exhaustive]
pub enum UnsupportedReason {
    UnsupportedKeyword = 0,
    UnionType = 1,
    OpenAdditionalProperties = 2,
    AdditionalPropertiesSchema = 3,
    RecursiveReference = 4,
    NonRegularRef = 5,
    InvalidPattern = 6,
    NumericRangeUnsupported = 7,
    SetDistinctness = 8,
    ExactlyOne = 9,
    Complement = 10,
    ConditionalApplicator = 11,
    DeferredObligation = 12,
    AnnotationDependent = 13,
    DynamicScope = 14,
    NonScalarLiteral = 15,
    LengthWithPattern = 16,
    FormatUnsupported = 17,
    FormatWithPattern = 18,
    NonIntegerNumericLiteral = 19,
    AllOfIntersectionUnsupported = 20,
    NumberBoundUnsupported = 21,
    OpenArrayTail = 22,
    StructuredBackendRequired = 23,
    RegexAssertionUnsupported = 24,
    RegexBackreferenceUnsupported = 25,
}

Why a keyword or shape is not accepted by the regular-subset engine. The discriminant is the stable machine code (folded into the content hash and pinned by a wire test); variants are append-only. advisory is display-only.

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.

UnsupportedKeyword = 0

A keyword with no supported arm in this dialect.

UnionType = 1

A type union or array of types (never narrowed to one).

OpenAdditionalProperties = 2

An object whose additional properties are open (absent or a non-false schema).

AdditionalPropertiesSchema = 3

additionalProperties given as a subschema rather than false.

RecursiveReference = 4

A cycle in the $ref graph (needs a pushdown grammar).

NonRegularRef = 5

A $ref to an external document or the network.

InvalidPattern = 6

A regex construct the anchored byte engine cannot accept.

NumericRangeUnsupported = 7

type:number, multipleOf, or a numeric bound outside the supported integer subset.

SetDistinctness = 8

uniqueItems (set distinctness is context-sensitive).

ExactlyOne = 9

oneOf (exactly-one is context-sensitive; never downgraded to a union).

Complement = 10

not (complement).

ConditionalApplicator = 11

if/then/else or dependentSchemas (conditional applicator).

DeferredObligation = 12

dependentRequired (a deferred obligation).

AnnotationDependent = 13

A keyword whose meaning depends on collected annotations.

DynamicScope = 14

$dynamicRef/$dynamicAnchor (dynamic scope).

NonScalarLiteral = 15

A non-scalar const/enum member.

LengthWithPattern = 16

A length-bounded string that also carries a pattern or a non-ASCII body.

FormatUnsupported = 17

A format this dialect does not enforce even under format_assertion.

FormatWithPattern = 18

A format combined with pattern, minLength, or maxLength on the same string.

NonIntegerNumericLiteral = 19

A const/enum numeric member whose lexical form is not a plain JSON integer token (a fraction, exponent, or magnitude outside i64), e.g. 1.0, 1e0.

AllOfIntersectionUnsupported = 20

allOf (language intersection needs a product-automaton construction this dialect does not build; never approximated as a union or a regex concatenation).

NumberBoundUnsupported = 21

A minimum/maximum bound on type:number. The engine does not build a decimal-comparison automaton for a bounded real range under the current profile, so only unbounded type:number is supported. This is a current-implementation limit, not a proof of non-representability.

OpenArrayTail = 22

Unconstrained array items (bare prefixItems, items:true, or no item schema): they admit arbitrary-depth JSON, which is not regular. A regular-item array or items:false is supported.

StructuredBackendRequired = 23

An OpenObject reached the byte-DFA compiler; it needs the structured backend instead.

RegexAssertionUnsupported = 24

A look-around assertion is outside the supported anchored regular subset.

RegexBackreferenceUnsupported = 25

A numeric or named regex backreference is not compiled as an automaton.

Implementations

impl UnsupportedReason

pub fn advisory(self) -> &'static str

A short, display-only description. Not the machine contract (the discriminant is).

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for UnsupportedReason

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl Clone for UnsupportedReason

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 UnsupportedReason

impl Debug for UnsupportedReason

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for UnsupportedReason

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl Encode for UnsupportedReason

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl Eq for UnsupportedReason

impl Hash for UnsupportedReason

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 UnsupportedReason

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for UnsupportedReason