# [−] [src] Struct syn::parse::Lookahead1

    pub struct Lookahead1<'a> { /* fields omitted */ }

Support for checking the next token in a stream to decide how to parse.

An important advantage over `ParseStream::peek` is that here we automatically construct an appropriate error message based on the token alternatives that get peeked. If you are producing your own error message, go ahead and use `ParseStream::peek` instead.

Use `ParseStream::lookahead1` to construct this object.

# Example

    use syn::{ConstParam, Ident, Lifetime, LifetimeDef, Result, Token, TypeParam};
    use syn::parse::{Parse, ParseStream};

    // A generic parameter, a single one of the comma-separated elements inside
    // angle brackets in:
    //
    //     fn f<T: Clone, 'a, 'b: 'a, const N: usize>() { ... }
    //
    // On invalid input, lookahead gives us a reasonable error message.
    //
    //     error: expected one of: identifier, lifetime, `const`
    //       |
    //     5 |     fn f<!Sized>() {}
    //       |          ^
    enum GenericParam {
        Type(TypeParam),
        Lifetime(LifetimeDef),
        Const(ConstParam),
    }

    impl Parse for GenericParam {
        fn parse(input: ParseStream) -> Result<Self> {
            let lookahead = input.lookahead1();
            if lookahead.peek(Ident) {
                input.parse().map(GenericParam::Type)
            } else if lookahead.peek(Lifetime) {
                input.parse().map(GenericParam::Lifetime)
            } else if lookahead.peek(Token![const]) {
                input.parse().map(GenericParam::Const)
            } else {
                Err(lookahead.error())
            }
        }
    }

## Implementations

### `impl<'a> Lookahead1<'a>` [src]

#### `pub fn peek<T: Peek>(&self, token: T) -> bool` [src]

Looks at the next token in the parse stream to determine whether it matches the requested type of token.

# Syntax

Note that this method does not use turbofish syntax. Pass the peek type inside of parentheses.

- `input.peek(Token![struct])`
- `input.peek(Token![==])`
- `input.peek(Ident)` (does not accept keywords)
- `input.peek(Ident::peek_any)`
- `input.peek(Lifetime)`
- `input.peek(token::Brace)`

#### `pub fn error(self) -> Error` [src]

Triggers an error at the current position of the parse stream.

The error message will identify all of the expected token types that have been peeked against this lookahead instance.

## Auto Trait Implementations

### `impl<'a> !RefUnwindSafe for Lookahead1<'a>`

### `impl<'a> !Send for Lookahead1<'a>`

### `impl<'a> !Sync for Lookahead1<'a>`

### `impl<'a> Unpin for Lookahead1<'a>`

### `impl<'a> UnwindSafe for Lookahead1<'a>`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.