Struct NonEmptyOption 

pub struct NonEmptyOption<T>(pub Option<T>);

NonEmptyOption<T> prevents Option from matching when T can succeed with empty input. It ensures None is returned when no tokens remain, regardless of whether T could succeed on an empty stream. This is crucial when parsing optional trailing content that should only match if tokens are actually available to consume.

Example

let mut token_iter = "ident".to_token_iter();

let parsed = NonEmptyOption::<Punct>::parser(&mut token_iter).unwrap();
assert_tokens_eq!(parsed, "");

Contrast with Option<T>

// Vec<T> can succeed with zero items
let mut token_iter = "".to_token_iter();

// Option<T> returns Some(empty_vec) even at EndOfStream
let parsed = Option::<Vec<Ident>>::parser(&mut token_iter).unwrap();
assert!(parsed.is_some());

// NonEmptyOption<T> returns None at EndOfStream
let mut token_iter = "".to_token_iter();
let parsed = NonEmptyOption::<Vec<Ident>>::parser(&mut token_iter).unwrap();
assert!(parsed.is_none());

Tuple Fields

0: Option<T>

Methods from Deref<Target = Option<T>>

pub fn is_some(&self) -> bool

Returns true if the option is a Some value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_some(), true);

let x: Option<u32> = None;
assert_eq!(x.is_some(), false);

pub fn is_none(&self) -> bool

Returns true if the option is a None value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_none(), false);

let x: Option<u32> = None;
assert_eq!(x.is_none(), true);

pub fn as_ref(&self) -> Option<&T>

Converts from &Option<T> to Option<&T>.

Examples

Calculates the length of an Option<String> as an Option<usize> without moving the String. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an Option to a reference to the value inside the original.

let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {text:?}");

pub fn as_pin_ref(self: Pin<&Option<T>>) -> Option<Pin<&T>>

Converts from Pin<&Option<T>> to Option<Pin<&T>>.

pub fn as_pin_mut(self: Pin<&mut Option<T>>) -> Option<Pin<&mut T>>

Converts from Pin<&mut Option<T>> to Option<Pin<&mut T>>.

pub fn as_slice(&self) -> &[T]

Returns a slice of the contained value, if any. If this is None, an empty slice is returned. This can be useful to have a single type of iterator over an Option or slice.

Note: Should you have an Option<&T> and wish to get a slice of T, you can unpack it via opt.map_or(&[], std::slice::from_ref).

Examples

assert_eq!(
    [Some(1234).as_slice(), None.as_slice()],
    [&[1234][..], &[][..]],
);

The inverse of this function is (discounting borrowing) [_]::first:

for i in [Some(1234_u16), None] {
    assert_eq!(i.as_ref(), i.as_slice().first());
}

pub fn as_deref(&self) -> Option<&<T as Deref>::Target>

where T: Deref,

Converts from Option<T> (or &Option<T>) to Option<&T::Target>.

Leaves the original Option in-place, creating a new one with a reference to the original one, additionally coercing the contents via Deref.

Examples

let x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref(), Some("hey"));

let x: Option<String> = None;
assert_eq!(x.as_deref(), None);

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

Examples

let x = Some(4);
assert_eq!(x.iter().next(), Some(&4));

let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);

Trait Implementations

impl<T> Clone for NonEmptyOption<T>

where T: Clone,

fn clone(&self) -> NonEmptyOption<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for NonEmptyOption<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for NonEmptyOption<T>

type Target = Option<T>

The resulting type after dereferencing.

fn deref(&self) -> &<NonEmptyOption<T> as Deref>::Target

Dereferences the value.

impl<T> Parser for NonEmptyOption<T>

where T: Parse,

fn parser(tokens: &mut TokenIter) -> Result<NonEmptyOption<T>, Error>

The actual parsing function that must be implemented. This mutates the tokens iterator directly. It should not be called from user code except for implementing parsers itself and then only when the rules below are followed.

impl<T> ToTokens for NonEmptyOption<T>

where T: ToTokens,

fn to_tokens(&self, tokens: &mut TokenStream)

Write &self to the given TokenStream.

fn to_token_iter(&self) -> TokenIter

Convert &self into a TokenIter object.

fn into_token_iter(self) -> TokenIter

where Self: Sized,

Convert self into a TokenIter object.

fn to_token_stream(&self) -> TokenStream

Convert &self into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self into a TokenStream object.

fn tokens_to_string(&self) -> String

Convert &self into a String object. This is mostly used in the test suite to compare the outputs. When the input is a &str then this parses it and returns a normalized String.