Support throwing closures

[Nemo157]

#![feature(stmt_expr_attributes, proc_macro_hygiene)]

type Error = usize;

fn main() {
    let x = #[fehler::throws] || 5;
    
    dbg!(x());
}

I expected this to work and print Ok(5), with an expansion something like

    let x = || Result<_, Error> { Ok({ 5 }) };

[withoutboats]

Yep, I just haven't yet bothered implementing it because stmt_expr_attributes etc are unstable features.

[ijackson]

I love fehler and I really really want it for my IEFEs and closures.

Is the expr -> stmt workaround not applicable for #[throws]?

Here's some code from my current project.

    let op = op.try_map(
      |()|{
        let mut ns = pc.prep_piecestate(p.as_ref(), pri)?;
        massage_prep_piecestate(pri, &mut ns);
        <Result<_,InternalError>>::Ok(ns)
      },

Experimentally, I tried this:

    let op = op.try_map(#[allow(some_random_thing)] {
      |()|{
        let mut ns = pc.prep_piecestate(p.as_ref(), pri)?;
        massage_prep_piecestate(pri, &mut ns);
        <Result<_,InternalError>>::Ok(ns)
      }},

and I got the expected warning about an unknown lint.

Then I could write

    let op = op.try_map(#[throws(InternalError)] {
      |()|{
        let mut ns = pc.prep_piecestate(p.as_ref(), pri)?;
        massage_prep_piecestate(pri, &mut ns);
        ns
      }},

The extra { } would be 1000% worth it.

Would it be too confusing if the default error type for #[throws] on a closure would be the error type for the containing function, rather than Error in the enclosing scope? That would save writing type Error = InternalError or whatever at the top of each relevant function...