Struct UnionParser 

pub struct UnionParser<'doc, 'ctx, T, E = ParseError> { /* private fields */ }

Helper for parsing union types from Eure documents.

Implements oneOf semantics:

• Exactly one variant must match
• Multiple matches resolved by registration order (priority)
• Short-circuits on first priority variant match
• When $variant extension or repr is specified, matches by name directly

Variant Resolution

Variant is determined by combining $variant extension and VariantRepr:

• Both agree on same name → use repr’s context (with tag excluded for Internal)
• $variant only (repr didn’t extract) → use original context
• Repr only → use repr’s context
• Conflict (different names) → ConflictingVariantTags error
• Neither → Untagged parsing (try all variants)

Example

impl<'doc> ParseDocument<'doc> for Description {
    fn parse(ctx: &ParseContext<'doc>) -> Result<Self, ParseError> {
        ctx.parse_union(VariantRepr::default())?
            .variant("string", |ctx| {
                let text: String = ctx.parse()?;
                Ok(Description::String(text))
            })
            .variant("markdown", |ctx| {
                let text: String = ctx.parse()?;
                Ok(Description::Markdown(text))
            })
            .parse()
    }
}

Implementations

impl<'doc, 'ctx, T, E> UnionParser<'doc, 'ctx, T, E>

where E: From<ParseError>,

pub fn variant<P: DocumentParser<'doc, Output = T, Error = E>>( self, name: &str, f: P, ) -> Self

Register a variant with short-circuit semantics (default).

When this variant matches in untagged mode, parsing succeeds immediately without checking other variants. Use definition order to express priority.

pub fn parse_variant<V: ParseDocument<'doc, Error = E>>( self, name: &str, then: impl FnMut(V) -> Result<T, E>, ) -> Self

Register a variant with short-circuit semantics using ParseDocument.

pub fn variant_unambiguous<P: DocumentParser<'doc, Output = T, Error = E>>( self, name: &str, f: P, ) -> Self

Register a variant with unambiguous semantics.

All unambiguous variants are tried to detect conflicts. If multiple unambiguous variants match, an AmbiguousUnion error is returned. Use for catch-all variants or when you need conflict detection.

pub fn parse_variant_unambiguous<V: ParseDocument<'doc, Error = E>>( self, name: &str, then: impl FnMut(V) -> Result<T, E>, ) -> Self

Register a variant with unambiguous semantics using ParseDocument.

pub fn parse(self) -> Result<T, E>

Execute the union parse with oneOf semantics.