[dtolnay]

Example: This parses a sequence of '+'-separated lifetimes and types like Vec<u8> + dyn Display + 'static, at least one of which must be a type.

use syn::{Lifetime, Token, Type};
use syn::parse::{Error, ParseStream, Result};

enum Thing {
    Lifetime(Lifetime),
    Type(Type),
}

fn parse_things(input: ParseStream) -> Result<Vec<Thing>> {
    let things_begin = input.cursor();
    let things_end;
    let mut things = Vec::new();
    let mut has_type = false;
    loop {
        if input.peek(Lifetime) {
            let lifetime: Lifetime = input.parse()?;
            things.push(Thing::Lifetime(lifetime));
        } else {
            let ty = input.call(Type::without_plus)?;
            things.push(Thing::Type(ty));
            has_type = true;
        }
        let plus_token: Option<Token![+]> = input.parse()?;
        if plus_token.is_none() {
            things_end = input.cursor();
            break;
        }
    }

    if has_type {
        Ok(things)
    } else {
        let msg = "things must not be all lifetimes, at least one type is required";
        Err(Error::new_range(things_begin..things_end, msg))
    }
}

error: things must not be all lifetimes, at least one type is required
 --> example.rs:4:23
  |
4 |     example!(THINGS = 'a + 'b, ...);
  |                       ^^^^^^^