Struct Parser 

pub struct Parser<'input, T: BorrowedInput<'input>> { /* private fields */ }

A YAML parser.

Implementations

impl<'input> Parser<'input, StrInput<'input>>

pub fn new_from_str(value: &'input str) -> Self

Create a parser over a borrowed string slice.

Every emitted event span has UTF-8 byte offsets into value: Span::byte_range returns Some(start..end), with ordered, in-bounds UTF-8 boundaries. This includes zero-length spans for implicit events and end-of-input. Span::slice returns Some when given the same, unchanged source string.

This guarantee applies to spans as emitted, before callers modify their markers. Byte offsets remain optional in Span because other inputs, such as Self::new_from_iter, do not provide them. Missing offsets must not be replaced with zero or with Marker::index, which counts characters rather than bytes.

pub fn new_from_str_with_options(value: &'input str, options: Options) -> Self

Create a parser over a borrowed string slice with configurable behavior and resource limits.

The byte-offset guarantee of Self::new_from_str also applies with custom options.

impl<T> Parser<'static, BufferedInput<T>>

where T: Iterator<Item = char>,

pub fn new_from_iter(iter: T) -> Self

Create a parser over an iterator of characters.

pub fn new_from_iter_with_options(iter: T, options: Options) -> Self

Create a parser over an iterator of characters with configurable behavior and resource limits.

impl<T> Parser<'static, FallibleBufferedInput<T>>

where T: Iterator<Item = Result<char, ErrorKind>>,

pub fn new_from_fallible_iter(iter: T) -> Self

Create a parser over a fallible iterator of characters.

The iterator’s None return value means clean end-of-input. An Err item reports a terminal source failure and is returned by the parser as a ScanError carrying the same ErrorKind. The iterator is not polled again after its first error.

pub fn new_from_fallible_iter_with_options(iter: T, options: Options) -> Self

Create a parser over a fallible iterator of characters with configurable behavior and resource limits.

The iterator’s None return value means clean end-of-input. An Err item reports a terminal source failure and is returned by the parser as a ScanError carrying the same ErrorKind. The iterator is not polled again after its first error.

impl<'input, T: BorrowedInput<'input>> Parser<'input, T>

pub fn anchor_offset(&self) -> usize

Return the next anchor ID that will be assigned by this parser.

pub fn set_anchor_offset(&mut self, offset: usize)

Set the next anchor ID that will be assigned by this parser.

pub fn new(src: T) -> Self

Create a parser over a custom input source.

pub fn with_options(src: T, options: Options) -> Self

Create a parser over a custom input source with configurable behavior and resource limits.

Use crate::options! to construct options without depending on exhaustive struct literal syntax. Without the comments feature, comment capture and emission are compiled out of both the parser and its scanner. YAML comments are still skipped and validated.

pub fn keep_tags(self, value: bool) -> Self

Configure whether tag directives remain active across document boundaries.

This behavior is non-standard as per the YAML specification but can be encountered in the wild. Passing true enables this non-standard extension and allows the parser to accept input from test QLJ7 of the yaml-test-suite:

%TAG !prefix! tag:example.com,2011:
--- !prefix!A
a: b
--- !prefix!B
c: d
--- !prefix!C
e: f

With keep_tags set to false, the above YAML is rejected. As per the specification, tags only apply to the document immediately following them. This would error on !prefix!B.

With keep_tags set to true, the above YAML is accepted by the parser.

pub fn peek(&mut self) -> Option<Result<&(Event<'input>, Span), ScanError>>

Try to load the next event and return it without consuming it from self.

Any subsequent call to Parser::peek will return the same value, until a call to Iterator::next, Parser::load, or Self::proceed_next_document. If the buffered value is a ScanError, Parser::next_event returns that error once and then the parser is exhausted.

Errors

Returns ScanError when loading the next event fails.

pub fn next_event(&mut self) -> Option<ParseResult<'input>>

Try to load the next event and return it, consuming it from self.

After this returns a ScanError, subsequent calls return None unless Self::proceed_next_document is called to recover at a document boundary.

Errors

Returns ScanError when loading the next event fails.

pub fn proceed_next_document(&mut self) -> Result<bool, ScanError>

Abandon the current document and resume at the next document boundary.

This can be called after an error from iteration, Self::peek, or Self::load, or during successful parsing to skip the remainder of a document. Before parsing starts it skips the first document. Immediately after Event::DocumentEnd it leaves the next document ready to read. Repeated calls skip successive documents.

Returns true when another document remains, including an empty or malformed document, and false at clean EOF. This looks past inter-document comments and end markers without consuming the next document’s events. Comments inspected by this lookahead are buffered for subsequent reads; with comment emission enabled, the configured comment-buffer limit applies. Syntax errors encountered in the next document remain available to normal parsing.

Read subsequent events using the usual parser methods. They start with the next Event::DocumentStart (possibly preceded by comments), or Event::StreamEnd if no document remains. An already consumed stream end stays exhausted. This method does not emit another Event::StreamStart.

After a syntax error, recovery scans forward from the scanner’s current position to a separated --- or valid ... at column zero, or EOF. An explicit end marker also permits a following implicit document and its directive prefix. Indented markers, inline markers, and scalar text such as ---suffix are not synchronization points. Input is never rewound; event spans retain their original source positions. If a directive prefix fails before its opening ---, that document’s body is skipped too.

Open collections, buffered events/comments, and anchor definitions of an abandoned document are discarded. No synthetic collection ends, document end, or error node are emitted for it: consumers building a tree must abandon or mark their own partial nodes. Anchor IDs remain unique across documents. Directives are reset as at a normal document boundary, including the Self::keep_tags policy.

Skipped syntax errors are suppressed. Recovery does not repair content within a document, preserve its anchors for another document, or validate the next document in advance. Ordinary parsing still stops at the first error unless this method is explicitly called. Scanning moves forward with work proportional to the skipped input; no diagnostic list is accumulated. Cancellation can be supplied through a fallible input source.

Example

use granit_parser::{Event, Parser};
let mut parser = Parser::new_from_str("broken: [1, 2\n---\nhealthy: true\n");
let error = parser.by_ref().find_map(Result::err).unwrap();
assert!(parser.next().is_none());
// Record the diagnostic and abandon any open nodes in the consumer's partial tree.
assert!(parser.proceed_next_document()?);
assert!(matches!(parser.next().unwrap()?.0, Event::DocumentStart(true, _)));
let rest = parser.collect::<Result<Vec<_>, _>>()?;
assert!(rest.iter().any(|(event, _)| event.scalar().is_some_and(|(v, _)| v == "healthy")));

Errors

Returns a source failure (including I/O, decoding, or cancellation errors supplied by the input). Source failures cannot be recovered and leave the parser exhausted. With comment emission enabled, also returns ErrorKind::TooManyComments if looking ahead would exceed the comment-buffer limit; parsing then stays exhausted until recovery is requested again.

pub fn load<R: SpannedEventReceiver<'input>>( &mut self, recv: &mut R, multi: bool, ) -> Result<(), ScanError>

Load the YAML from the stream in self, pushing events into recv.

The contents of the stream are parsed and the corresponding events are sent into the receiver. For detailed explanations about how events work, see EventReceiver.

If multi is set to true, the parser will allow parsing of multiple YAML documents inside the stream.

Use this method when event handling is infallible. If receiver code can return an application error and should stop parsing, use Parser::try_load instead. If the caller should directly control when the next event is read, use Parser’s core::iter::Iterator implementation.

Note that any EventReceiver is also a SpannedEventReceiver, so implementing the former is enough to call this function.

After a scan error, the parser is exhausted: Parser::peek and Parser::next_event return None, and further calls to load or Parser::try_load return Ok(()) without emitting events.

Example

struct EventSink<'input> {
    events: Vec<Event<'input>>,
}

impl<'input> EventReceiver<'input> for EventSink<'input> {
    fn on_event(&mut self, ev: Event<'input>) {
        self.events.push(ev);
    }
}

let mut parser = Parser::new_from_str("a: 1\n");
let mut sink = EventSink { events: Vec::new() };

parser.load(&mut sink, false)?;

assert!(sink
    .events
    .iter()
    .any(|ev| matches!(ev, Event::Scalar(value, ..) if value == "a")));

Errors

Returns ScanError when loading fails.

pub fn try_load<R: TrySpannedEventReceiver<'input>>( &mut self, recv: &mut R, multi: bool, ) -> Result<(), TryLoadError<R::Error>>

Load the YAML from the stream in self, pushing events into recv.

This is the fallible counterpart to Parser::load. If recv returns an error, parsing stops immediately and that error is returned as TryLoadError::Receiver.

If multi is set to true, the parser will allow parsing of multiple YAML documents inside the stream.

If the receiver returns an error, the parser is left positioned immediately after the event that caused the receiver error. Callers should treat the parser as partially consumed.

After a scan error, the parser is exhausted: Parser::peek and Parser::next_event return None, and further calls to try_load or Parser::load return Ok(()) without emitting events.

Example

#[derive(Debug, PartialEq, Eq)]
enum ValidationError {
    ForbiddenScalar,
}

struct Validator;

impl<'input> TryEventReceiver<'input> for Validator {
    type Error = ValidationError;

    fn on_event(&mut self, ev: Event<'input>) -> Result<(), Self::Error> {
        if matches!(ev, Event::Scalar(value, ..) if value.as_ref() == "bad") {
            Err(ValidationError::ForbiddenScalar)
        } else {
            Ok(())
        }
    }
}

let mut parser = Parser::new_from_str("value: bad\n");
let mut validator = Validator;

let err = parser.try_load(&mut validator, false).unwrap_err();

assert_eq!(err, TryLoadError::Receiver(ValidationError::ForbiddenScalar));

Errors

Returns TryLoadError::Scan when scanning or parsing the stream fails. Returns TryLoadError::Receiver when recv returns an error.

Trait Implementations

impl<'input, T: Debug + BorrowedInput<'input>> Debug for Parser<'input, T>

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

Formats the value using the given formatter.

impl<'input, T: BorrowedInput<'input>> FusedIterator for Parser<'input, T>

impl<'input, T: BorrowedInput<'input>> Iterator for Parser<'input, T>

type Item = Result<(Event<'input>, Span), ScanError>

The type of the elements being iterated over.

fn next(&mut self) -> Option<Self::Item>

Advances the iterator and returns the next value.

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

where Self: Sized,

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

where Self: Sized,

Consumes the iterator, returning the last element.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places a copy of separator between items of the original iterator.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places an item generated by separator between items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Item),

Calls a closure on each element of an iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self>

where Self: Sized, Self::Item: IntoIterator,

Creates an iterator that flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

🔬This is a nightly-only experimental API. (iter_map_windows)

Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f. Like slice::windows(), the windows during mapping overlap as well.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Iterator.

fn collect<B>(self) -> B

where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection.

fn try_collect<B>( &mut self, ) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType

where Self: Sized, Self::Item: Try, <Self::Item as Try>::Residual: Residual<B>, B: FromIterator<<Self::Item as Try>::Output>,

🔬This is a nightly-only experimental API. (iterator_try_collect)

Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn all<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns the first true result or the first error.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Self::Item) -> bool,

Searches for an element in an iterator, returning its index.

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: Copy + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: Clone + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements.

fn cmp<I>(self, other: I) -> Ordering

where I: IntoIterator<Item = Self::Item>, Self::Item: Ord, Self: Sized,

Lexicographically compares the elements of this Iterator with those of another.

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the PartialOrd elements of this Iterator with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_order_by)

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted(self) -> bool

where Self: Sized, Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.

impl<'input, T: BorrowedInput<'input>> ParserTrait<'input> for Parser<'input, T>

fn peek(&mut self) -> Option<Result<&(Event<'input>, Span), ScanError>>

Try to load the next event and return it without consuming it from self.

fn next_event(&mut self) -> Option<ParseResult<'input>>

Try to load the next event and return it, consuming it from self.

fn load<R: SpannedEventReceiver<'input>>( &mut self, recv: &mut R, multi: bool, ) -> Result<(), ScanError>

Load the YAML from the stream in self, pushing events into recv.

fn try_load<R: TrySpannedEventReceiver<'input>>( &mut self, recv: &mut R, multi: bool, ) -> Result<(), TryLoadError<R::Error>>

Load the YAML from the stream in self, stopping if recv returns an error.