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

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

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);
🔬This is a nightly-only experimental API. (is_some_with)

Returns true if the option is a Some and the value inside of it matches a predicate.

Examples
#![feature(is_some_with)]

let x: Option<u32> = Some(2);
assert_eq!(x.is_some_and(|&x| x > 1), true);

let x: Option<u32> = Some(0);
assert_eq!(x.is_some_and(|&x| x > 1), false);

let x: Option<u32> = None;
assert_eq!(x.is_some_and(|&x| x > 1), false);

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);

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

Examples

Converts an Option<String> into an Option<usize>, preserving the original. 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:?}");

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));

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

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

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);

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()));

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);

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);

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);

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));
🔬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));

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));

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);

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);
🔬This is a nightly-only experimental API. (option_result_contains)

Returns true if the option is a Some value containing the given value.

Examples
#![feature(option_result_contains)]

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

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

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

Trait Implementations

Returns a copy of the value. Read more
Performs copy-assignment from source. Read more
Formats the value using the given formatter. Read more
Returns the “default value” for a type. Read more
The resulting type after dereferencing.
Dereferences the value.
Mutably dereferences the value.
Formats the value using the given formatter. Read more
Converts to this type from the input type.
Converts to this type from the input type.
Converts to this type from the input type.
Converts to this type from the input type.
The associated error which can be returned from parsing.
Parses a string s to return a value of this type. Read more
Feeds this value into the given Hasher. Read more
Feeds a slice of this type into the given Hasher. Read more
The type of the elements being iterated over.
Which kind of iterator are we turning this into?
Creates an iterator from a value. Read more
The type of the elements being iterated over.
Which kind of iterator are we turning this into?
Creates an iterator from a value. Read more
The type of the elements being iterated over.
Which kind of iterator are we turning this into?
Creates an iterator from a value. Read more
This method tests for self and other values to be equal, and is used by ==. Read more
This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason. Read more
Write self to the given TokenStream. Read more
Convert self directly into a TokenStream object. Read more
Convert self directly into a TokenStream object. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more
Converts to this type from the input type.

Returns the argument unchanged.

Calls U::from(self).

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

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

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);

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);
The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
Uses borrowed data to replace owned data, usually by cloning. Read more
Converts the given value to a String. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.