Struct Partial 

pub struct Partial;

The partial completeness: the input is a prefix of a stream that may still grow.

Carries a runtime is_final: bool — a fact about the world, which the driver states by sealing the input when the last chunk lands (parse_partial’s is_final argument). While non-final the frontier rules hold back any construct that might be extended by later input, surfacing an Incomplete so the caller can refill and re-drive; once final it behaves exactly like Complete.

A parser cannot reach the bit: it is settable only through the owning input, which an InputRef borrows for its whole life. See Completeness.

The rules hold back only what more input could change. A terminal condition — a resource-limit trip and the poison boundary it latches — is not such a thing: it fires through the frontier rather than hiding behind them, so a streaming caller is never told to refill for a limit that can never clear. See terminal beats incomplete.

Trait Implementations

impl Clone for Partial

fn clone(&self) -> Partial

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Completeness for Partial

const PARTIAL: bool = true

true for Partial, false for Complete. Every frontier rule is written if Cmpl::PARTIAL && …, so this constant is what erases the rules from the complete path at monomorphization.

type Finality = bool

Per-input storage for the runtime is_final flag. A zero-sized () for Complete (so carrying it costs nothing and never grows the input) and a bool for Partial.

fn initial() -> Self::Finality

The finality a freshly-constructed input starts at: open — the stream has not ended. Complete has nothing to store (a whole input is final by definition); Partial starts non-final and reaches finality only through seal.

fn is_final(finality: &Self::Finality) -> bool

Reads whether the input is final. Always true for Complete (a whole input is final by definition — every frontier rule is thereby inert); the stored flag for Partial.

fn seal(finality: &mut Self::Finality)

Seals the input: the stream has ended, and no further bytes will arrive.

impl Copy for Partial

impl Debug for Partial

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

Formats the value using the given formatter.

impl Eq for Partial

impl Hash for Partial

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 Partial

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Partial

impl<'inp, L, Ctx, Lang: ?Sized> SurfaceIncomplete<'inp, L, Ctx, Lang> for Partial

where L: Lexer<'inp>, Ctx: ParseContext<'inp, L, Lang>, <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error: From<Incomplete<L::Offset>> + MaybeIncomplete,

fn surface_incomplete( offset: L::Offset, ) -> <Ctx::Emitter as Emitter<'inp, L, Lang>>::Error

Builds the emitter’s error as an Incomplete at offset — the offset the input ran out at (the frontier). Called only in partial, non-final mode.

fn is_incomplete_error( err: &<Ctx::Emitter as Emitter<'inp, L, Lang>>::Error, ) -> bool

Whether err is the partial-input Incomplete sentinel.