Struct PartialClosure

pub struct PartialClosure {
    pub lifetimes: Option<BoundLifetimes>,
    pub constness: Option<Const>,
    pub movability: Option<Static>,
    pub asyncness: Option<Async>,
    pub capture: Option<Move>,
    pub or1_token: Or,
    pub inputs: Punctuated<Pat, Comma>,
    pub or2_token: Or,
    pub output: ReturnType,
    pub body: PartialExpr,
}

A closure whose body might not be valid rust code but we want to interpret it regardless. This lets us provide expansions in way more cases than normal closures at the expense of an increased mainteance burden and complexity.

We do our best to reuse the same logic from partial exprs for the body of the PartialClosure. The code here is simply stolen from syn::ExprClosure and lightly modified to work with PartialExprs. We only removed the attrs field and changed the body to be a PartialExpr. Otherwise, it’s a direct copy of the original.

Fields

lifetimes: Option<BoundLifetimes>

constness: Option<Const>

movability: Option<Static>

asyncness: Option<Async>

capture: Option<Move>

or1_token: Or

inputs: Punctuated<Pat, Comma>

or2_token: Or

output: ReturnType

body: PartialExpr

Implementations

impl PartialClosure

pub fn as_expr(&self) -> Result<Expr>

Convert this partial closure into a full closure if it is valid Returns err if the internal tokens can’t be parsed as a closure

Trait Implementations

impl Clone for PartialClosure

fn clone(&self) -> PartialClosure

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PartialClosure

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

Formats the value using the given formatter.

impl Hash for PartialClosure

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Parse for PartialClosure

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

impl PartialEq for PartialClosure

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToTokens for PartialClosure

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

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self directly into a TokenStream object.

impl Eq for PartialClosure