fn parse<
        '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) -> Result<O, Vec<Self::Error>> where Self: Sized {
        let (output, errors) = self.parse_recovery(stream);
        if errors.is_empty() {
            Ok(output.expect("Parsing failed, but no errors were emitted. This is troubling, to say the least."))
        } else {
            Err(errors)
        }
    }
/// Parse a stream of tokens, yielding an output *or* any errors that were encountered along the way.
///
/// If you wish to attempt to produce an output even if errors are encountered, use [`Parser::parse_recovery`].
///
/// 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.
Parse a stream of tokens, yielding an output *or* any errors that were encountered along the way.
If you wish to attempt to produce an output even if errors are encountered, use [`Parser::parse_recovery`].

Although the signature of this function looks complicated, it's simpler than you think.
Parse a stream of tokens yielding an output * or * any errors that were encountered along the way . If you wish to attempt to produce an output even if errors are encountered use [ ` Parser :: parse_recovery ` ] . Although the signature of this function looks complicated it ' s simpler than you think .
fn parse<
        '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) -> Result<O, Vec<Self::Error>> where Self: Sized {
        let (output, errors) = self.parse_recovery(stream);
        if errors.is_empty() {
            Ok(output.expect("Parsing failed, but no errors were emitted. This is troubling, to say the least."))
        } else {
            Err(errors)
        }
    }
fn parse < ' 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 ) -> Result < O , Vec < Self :: Error > > where Self : Sized { let ( output , errors ) = self . parse_recovery ( stream ) ; if errors . is_empty ( ) { Ok ( output . expect ( " " ) ) } else { Err ( errors ) } }
Parse a stream of tokens, yielding an output *or* any errors that were encountered along the way.
Parse a stream of tokens yielding an output * or * any errors that were encountered along the way .
&self
stream
S