fn parse_recovery_verbose<
        'a,
        Iter: Iterator<Item = (I, <Self::Error as Error<I>>::Span)> + 'a,
        S: Into<Stream<'a, I, <Self::Error as Error<I>>::Span, Iter>>,
    >(&self, stream: S) -> (Option<O>, Vec<Self::Error>) where Self: Sized {
        let mut debugger = Verbose::new();
        let res = parse_recovery_inner(self, &mut debugger, stream);
        debugger.print();
        res
    }
/// Parse a stream of tokens, yielding an output if possible, and any errors encountered along the way. Unlike
/// [`Parser::parse_recovery`], this function will produce verbose debugging output as it executes.
///
/// If you don't care about producing an output if errors are encountered, use `Parser::parse` instead.
///
/// Although the signature of this function looks complicated, it's simpler than you think! You can pass a
/// [`&[I]`], a [`&str`], or a [`Stream`] to it.
///
/// You'll probably want to make sure that this doesn't end up in production code: it exists only to help you debug
/// your parser. Additionally, its API is quite likely to change in future versions.
Parse a stream of tokens, yielding an output if possible, and any errors encountered along the way. Unlike
[`Parser::parse_recovery`], this function will produce verbose debugging output as it executes.

If you don't care about producing an output if errors are encountered, use `Parser::parse` instead.

Although the signature of this function looks complicated, it's simpler than you think.

You'll probably want to make sure that this doesn't end up in production code: it exists only to help you debug
your parser. Additionally, its API is quite likely to change in future versions.
Parse a stream of tokens yielding an output if possible and any errors encountered along the way . Unlike [ ` Parser :: parse_recovery ` ] this function will produce verbose debugging output as it executes . If you don ' t care about producing an output if errors are encountered use ` Parser :: parse ` instead . Although the signature of this function looks complicated it ' s simpler than you think . You ' ll probably want to make sure that this doesn ' t end up in production code : it exists only to help you debug your parser . Additionally its API is quite likely to change in future versions .
fn parse_recovery_verbose<
        'a,
        Iter: Iterator<Item = (I, <Self::Error as Error<I>>::Span)> + 'a,
        S: Into<Stream<'a, I, <Self::Error as Error<I>>::Span, Iter>>,
    >(&self, stream: S) -> (Option<O>, Vec<Self::Error>) where Self: Sized {
        let mut debugger = Verbose::new();
        let res = parse_recovery_inner(self, &mut debugger, stream);
        debugger.print();
        res
    }
fn parse_recovery_verbose < ' a , Iter : Iterator < Item = ( I , < Self :: Error as Error < I > > :: Span ) > + ' a , S : Into < Stream < ' a , I , < Self :: Error as Error < I > > :: Span , Iter > > , > ( & self , stream : S ) -> ( Option < O > , Vec < Self :: Error > ) where Self : Sized { let mut debugger = Verbose :: new ( ) ; let res = parse_recovery_inner ( self , & mut debugger , stream ) ; debugger . print ( ) ; res }
Parse a stream of tokens, yielding an output if possible, and any errors encountered along the way.
Parse a stream of tokens yielding an output if possible and any errors encountered along the way .
&self
stream
S