Struct parsel::ast::Maybe

source ·
pub struct Maybe<P, T = Empty> { /* private fields */ }
Expand description

Parses an optional expression introduced by some lookahead tokens.

#[derive(PartialEq, Eq, Debug, Parse, ToTokens)]
enum Ty {
    Named(Ident),
    Ref(
        token::And,
        #[parsel(recursive)]
        Box<Self>,
    ),
    Opt(
        token::Question,
        #[parsel(recursive)]
        Box<Self>,
    ),
}

#[derive(PartialEq, Eq, Debug, Parse, ToTokens)]
struct TyAnnot {
    colon: token::Colon,
    ty: Ty,
}

#[derive(PartialEq, Eq, Debug, Parse, ToTokens)]
struct Function {
    kw_fn: token::Fn,
    name: Ident,
    argument: Paren<Maybe<Ident, TyAnnot>>,
    return_ty: Maybe<token::RArrow, Ty>,
    body: Brace<Empty>,
}

let unit_to_unit_function: Function = parse_quote!{
    fn foo() {}
};
assert_eq!(
    unit_to_unit_function,
    Function {
        kw_fn: Default::default(),
        name: ident("foo"),
        argument: Paren::default(),
        return_ty: Maybe::default(),
        body: Brace::default(),
    }
);

let unit_to_opt_function: Function = parse_quote!{
    fn another_name() -> ?Rofl {}
};
assert_eq!(
    unit_to_opt_function,
    Function {
        kw_fn: Default::default(),
        name: ident("another_name"),
        argument: Paren::default(),
        return_ty: Maybe::from((
            token::RArrow::default(),
            Ty::Opt(
                token::Question::default(),
                Box::new(Ty::Named(ident("Rofl"))),
            )
        )),
        body: Brace::default(),
    }
);

let opt_to_ref_function: Function = parse_quote!{
    fn fn_3(the_arg: ?&DoubleTrouble) -> &Indirect {}
};
assert_eq!(
    opt_to_ref_function,
    Function {
        kw_fn: Default::default(),
        name: ident("fn_3"),
        argument: Paren::from(Maybe::from((
            ident("the_arg"),
            TyAnnot {
                colon: Default::default(),
                ty: Ty::Opt(
                    token::Question::default(),
                    Box::new(Ty::Ref(
                        token::And::default(),
                        Box::new(Ty::Named(ident("DoubleTrouble"))),
                    )),
                )
            }
        ))),
        return_ty: Maybe::from((
            token::RArrow::default(),
            Ty::Ref(
                token::And::default(),
                Box::new(Ty::Named(ident("Indirect"))),
            )
        )),
        body: Brace::default(),
    }
);

Implementations§

source§

impl<P, T> Maybe<P, T>

source

pub const fn new() -> Self

source

pub fn as_prefix(&self) -> Option<&P>

source

pub fn as_prefix_mut(&mut self) -> Option<&mut P>

source

pub fn into_prefix(self) -> Option<P>

source

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

source

pub fn as_mut(&mut self) -> Option<&mut T>

source

pub fn into_inner(self) -> Option<T>

source

pub fn as_parts(&self) -> Option<&(P, T)>

source

pub fn as_parts_mut(&mut self) -> Option<&mut (P, T)>

source

pub fn into_parts(self) -> Option<(P, T)>

source

pub fn into_prefix_iter(self) -> IntoIter<P>

source

pub fn prefix_iter(&self) -> IntoIter<&P>

source

pub fn prefix_iter_mut(&mut self) -> IntoIter<&mut P>

source

pub fn iter(&self) -> IntoIter<&T>

source

pub fn iter_mut(&mut self) -> IntoIter<&mut T>

source

pub fn into_parts_iter(self) -> IntoIter<(P, T)>

source

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

source

pub fn parts_iter_mut(&mut self) -> IterMut<'_, (P, T)>

Methods from Deref<Target = Option<(P, T)>>§

1.0.0 · source

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);
1.0.0 · source

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);
1.0.0 · source

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:?}");
1.0.0 · source

pub fn as_mut(&mut self) -> Option<&mut T>

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

Examples
let mut x = Some(2);
match x.as_mut() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));
1.33.0 · source

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

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

1.33.0 · source

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>>.

source

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

🔬This is a nightly-only experimental API. (option_as_slice)

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
#![feature(option_as_slice)]

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

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

#![feature(option_as_slice)]

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

pub fn as_mut_slice(&mut self) -> &mut [T]

🔬This is a nightly-only experimental API. (option_as_slice)

Returns a mutable 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<&mut T> instead of a &mut Option<T>, which this method takes, you can obtain a mutable slice via opt.map_or(&mut [], std::slice::from_mut).

Examples
#![feature(option_as_slice)]

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

The result is a mutable slice of zero or one items that points into our original Option:

#![feature(option_as_slice)]

let mut x = Some(1234);
x.as_mut_slice()[0] += 1;
assert_eq!(x, Some(1235));

The inverse of this method (discounting borrowing) is [_]::first_mut:

#![feature(option_as_slice)]

assert_eq!(Some(123).as_mut_slice().first_mut(), Some(&mut 123))
1.40.0 · source

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);
1.40.0 · source

pub fn as_deref_mut(&mut self) -> Option<&mut <T as Deref>::Target>where T: DerefMut,

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

Leaves the original Option in-place, creating a new one containing a mutable reference to the inner type’s Deref::Target type.

Examples
let mut x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref_mut().map(|x| {
    x.make_ascii_uppercase();
    x
}), Some("HEY".to_owned().as_mut_str()));
1.0.0 · source

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);
1.0.0 · source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the possibly contained value.

Examples
let mut x = Some(4);
match x.iter_mut().next() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));

let mut x: Option<u32> = None;
assert_eq!(x.iter_mut().next(), None);
1.53.0 · source

pub fn insert(&mut self, value: T) -> &mut T

Inserts value into the option, then returns a mutable reference to it.

If the option already contains a value, the old value is dropped.

See also Option::get_or_insert, which doesn’t update the value if the option already contains Some.

Example
let mut opt = None;
let val = opt.insert(1);
assert_eq!(*val, 1);
assert_eq!(opt.unwrap(), 1);
let val = opt.insert(2);
assert_eq!(*val, 2);
*val = 3;
assert_eq!(opt.unwrap(), 3);
1.20.0 · source

pub fn get_or_insert(&mut self, value: T) -> &mut T

Inserts value into the option if it is None, then returns a mutable reference to the contained value.

See also Option::insert, which updates the value even if the option already contains Some.

Examples
let mut x = None;

{
    let y: &mut u32 = x.get_or_insert(5);
    assert_eq!(y, &5);

    *y = 7;
}

assert_eq!(x, Some(7));
source

pub fn get_or_insert_default(&mut self) -> &mut Twhere T: Default,

🔬This is a nightly-only experimental API. (option_get_or_insert_default)

Inserts the default value into the option if it is None, then returns a mutable reference to the contained value.

Examples
#![feature(option_get_or_insert_default)]

let mut x = None;

{
    let y: &mut u32 = x.get_or_insert_default();
    assert_eq!(y, &0);

    *y = 7;
}

assert_eq!(x, Some(7));
1.20.0 · source

pub fn get_or_insert_with<F>(&mut self, f: F) -> &mut Twhere F: FnOnce() -> T,

Inserts a value computed from f into the option if it is None, then returns a mutable reference to the contained value.

Examples
let mut x = None;

{
    let y: &mut u32 = x.get_or_insert_with(|| 5);
    assert_eq!(y, &5);

    *y = 7;
}

assert_eq!(x, Some(7));
1.0.0 · source

pub fn take(&mut self) -> Option<T>

Takes the value out of the option, leaving a None in its place.

Examples
let mut x = Some(2);
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, Some(2));

let mut x: Option<u32> = None;
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, None);
1.31.0 · source

pub fn replace(&mut self, value: T) -> Option<T>

Replaces the actual value in the option by the value given in parameter, returning the old value if present, leaving a Some in its place without deinitializing either one.

Examples
let mut x = Some(2);
let old = x.replace(5);
assert_eq!(x, Some(5));
assert_eq!(old, Some(2));

let mut x = None;
let old = x.replace(3);
assert_eq!(x, Some(3));
assert_eq!(old, None);

Trait Implementations§

source§

impl<P: Clone, T: Clone> Clone for Maybe<P, T>

source§

fn clone(&self) -> Maybe<P, T>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<P, T> Debug for Maybe<P, T>where P: Debug, T: Debug,

source§

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

Formats the value using the given formatter. Read more
source§

impl<P, T> Default for Maybe<P, T>

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl<P, T> Deref for Maybe<P, T>

§

type Target = Option<(P, T)>

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl<P, T> DerefMut for Maybe<P, T>

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl<P, T> Display for Maybe<P, T>where P: ToTokens, T: ToTokens,

source§

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

Formats the value using the given formatter. Read more
source§

impl<P, T> From<(P, T)> for Maybe<P, T>

source§

fn from(parts: (P, T)) -> Self

Converts to this type from the input type.
source§

impl<P, T> From<Option<(P, T)>> for Maybe<P, T>

source§

fn from(inner: Option<(P, T)>) -> Self

Converts to this type from the input type.
source§

impl<P: Default, T> From<Option<T>> for Maybe<P, T>

source§

fn from(inner: Option<T>) -> Self

Converts to this type from the input type.
source§

impl<P: Default, T> From<T> for Maybe<P, T>

source§

fn from(tail: T) -> Self

Converts to this type from the input type.
source§

impl<P, T> FromStr for Maybe<P, T>where P: Parse, T: Parse,

§

type Err = Error

The associated error which can be returned from parsing.
source§

fn from_str(string: &str) -> Result<Self>

Parses a string s to return a value of this type. Read more
source§

impl<P: Hash, T: Hash> Hash for Maybe<P, T>

source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl<'a, P, T> IntoIterator for &'a Maybe<P, T>

§

type Item = &'a T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<&'a T>

Which kind of iterator are we turning this into?
source§

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more
source§

impl<'a, P, T> IntoIterator for &'a mut Maybe<P, T>

§

type Item = &'a mut T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<&'a mut T>

Which kind of iterator are we turning this into?
source§

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more
source§

impl<P, T> IntoIterator for Maybe<P, T>

§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?
source§

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more
source§

impl<P, T> Parse for Maybe<P, T>where P: Parse, T: Parse,

source§

fn parse(input: ParseStream<'_>) -> Result<Self>

source§

impl<P: PartialEq, T: PartialEq> PartialEq<Maybe<P, T>> for Maybe<P, T>

source§

fn eq(&self, other: &Maybe<P, T>) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<P, T> ToTokens for Maybe<P, T>where P: ToTokens, T: ToTokens,

source§

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

Write self to the given TokenStream. Read more
source§

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object. Read more
source§

fn into_token_stream(self) -> TokenStreamwhere Self: Sized,

Convert self directly into a TokenStream object. Read more
source§

impl<P: Copy, T: Copy> Copy for Maybe<P, T>

source§

impl<P: Eq, T: Eq> Eq for Maybe<P, T>

source§

impl<P, T> StructuralEq for Maybe<P, T>

source§

impl<P, T> StructuralPartialEq for Maybe<P, T>

Auto Trait Implementations§

§

impl<P, T> RefUnwindSafe for Maybe<P, T>where P: RefUnwindSafe, T: RefUnwindSafe,

§

impl<P, T> Send for Maybe<P, T>where P: Send, T: Send,

§

impl<P, T> Sync for Maybe<P, T>where P: Sync, T: Sync,

§

impl<P, T> Unpin for Maybe<P, T>where P: Unpin, T: Unpin,

§

impl<P, T> UnwindSafe for Maybe<P, T>where P: UnwindSafe, T: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<!> for T

const: unstable · source§

fn from(t: !) -> T

Converts to this type from the input type.
source§

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> Spanned for Twhere T: Spanned + ?Sized,

source§

fn span(&self) -> Span

Returns a Span covering the complete contents of this syntax tree node, or Span::call_site() if this node is empty.
source§

impl<T> SpannedExt for Twhere T: Spanned + ?Sized,

source§

fn byte_range(&self, source: &str) -> Range<usize>

TODO(H2CO3): a faster, less naive implementation would be great. We should use the byte offset of start to compute that of end, sparing the double scan of the source up until the start location.

let source = r#"
   -3.667
  1248  "string ű literal"
      "wíőzs"
"#;
let tokens: Many<Lit> = source.parse()?;

assert_eq!(tokens.len(), 4);
assert_eq!(tokens[0].byte_range(source),  4..10);
assert_eq!(tokens[1].byte_range(source), 13..17);
assert_eq!(tokens[2].byte_range(source), 19..38);
assert_eq!(tokens[3].byte_range(source), 45..54);
source§

fn char_range(&self, source: &str) -> Range<usize>

TODO(H2CO3): a faster, less naive implementation would be great. We should use the char offset of start to compute that of end, sparing the double scan of the source up until the start location.

let source = r#"
   -3.667
  1248  "string ű literal"
      "wíőzs"
"#;
let tokens: Many<Lit> = source.parse()?;

assert_eq!(tokens.len(), 4);
assert_eq!(tokens[0].char_range(source),  4..10);
assert_eq!(tokens[1].char_range(source), 13..17);
assert_eq!(tokens[2].char_range(source), 19..37);
assert_eq!(tokens[3].char_range(source), 44..51);
source§

fn format_span(&self) -> SpanDisplay

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

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

The type returned in the event of a conversion error.
const: unstable · source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.