[derive(Parsable)]

struct Test(Number, Comma, Number);

// generated code impl Parse for Test { fn parse(value: &mut CharStream) -> Result { let inner0 = Number::parse(value)?; let _inner1 = Comma::parse(value)?; let _inner2 = Number::parse(value)?; Ok(Self(inner0, _inner1, _inner2)) }

fn span(&self) -> Span {
    Span::new(self.0.span().start, self.2.span().end)
}

}

[derive(Parsable)]

struct TestWhiteSpace(#[whitespace(KeepAll)] [tokens::Hyphen; 3], Number);

// generated code impl Parse for TestWhiteSpace { fn parse(value: &mut CharStream) -> Result { let _inner0 = { let _whitespacevalue = value.clone(); _whitespacevalue.set_whitespace(WhiteSpaceType::KeepAll);

        let inner = <[tokens::Hyphen; 3]>::parse(&mut __white_space_value);
        value.goto(__white_space_value.position())?;
        inner
    }?;
    let __inner_1 = Number::parse(value)?;
    Ok(Self(__inner_0, __inner_1))
}

fn span(&self) -> Span {
    Span::new(self.0.span().start, self.1.span().end)
}

}

[derive(Parsable)]

struct TestValue(#[value("test", "other")] Identifier, Number);

// generated code impl Parse for TestWhiteSpace { fn parse(value: &mut CharStream) -> Result { let inner0 = match Identifier::parse(value) { Ok(inner0) if inner0 == "test" => _inner0, Ok(inner0) if inner0 == "other" => _inner0, Ok(inner0) => return Err(ParseError("Value was not one of the expected values.", value.position())), Err(error) => return Err(error) }; let inner1 = Number::parse(value)?; Ok(Self(inner0, _inner1)) }

fn span(&self) -> Span {
    Span::new(self.0.span().start, self.1.span().end)
}

}

[derive(Parsable)]

struct TestValueWhiteSpace(#[whitespace(Indent)] #[value("test", "other")] Identifier, Number);

// generated code impl Parse for TestWhiteSpace { fn parse(value: &mut CharStream) -> Result { let _inner0 = match { let _whitespacevalue = value.clone(); _whitespacevalue.set_whitespace(WhiteSpaceType::Indent);

        let inner = Identifier::parse(&mut __white_space_value);
        value.goto(__white_space_value.position())?;
        inner
    } {
        Ok(__inner_0) if __inner_0 == "test" => __inner_0,
        Ok(__inner_0) if __inner_0 == "other" => __inner_0,
        Ok(__inner_0) => return Err(ParseError("Value was not one of the expected values.", value.position())),
        Err(error) => return Err(error)
    };
    let __inner_1 = Number::parse(value)?;
    Ok(Self(__inner_0, __inner_1))
}

fn span(&self) -> Span {
    Span::new(self.0.span().start, self.1.span().end)
}

} ```

For named structs, it should look like this: ```rust

[derive(Parsable)]

struct Test { x: Number, comma: Comma, y: Number }

// generated code impl Parse for Test { fn parse(value: &mut CharStream) -> Result { let _innerx = Number::parse(value)?; let _innercomma = Comma::parse(value)?; let _innery = Number::parse(value)?; Ok(Self { x: _innerx, comma: _innercomma, y: _innery}) }

fn span(&self) -> Span {
    Span::new(self.x.span().start, self.y.span().end)
}

}

[derive(Parsable)]

struct TestWhiteSpace { #[whitespace(Indent)] x: Number, comma: Comma, y: Number }

// generated code impl Parse for Test { fn parse(value: &mut CharStream) -> Result { let _innerx = { let _whitespacevalue = value.clone(); _whitespacevalue.set_whitespace(WhiteSpaceType::Indent);

        let inner = Number::parse(&mut __white_space_value);
        value.goto(__white_space_value.position())?;
        inner
    }?;
    let __inner_comma = Comma::parse(value)?;
    let __inner_y = Number::parse(value)?;
    Ok(Self { x: __inner_x, comma: __inner_comma, y: __inner_y})
}

fn span(&self) -> Span {
    Span::new(self.x.span().start, self.y.span().end)
}

}

[derive(Parsable)]

struct TestValue { #[value(69, 420)] x: Number, comma: Comma, y: Number }

// generated code impl Parse for Test { fn parse(value: &mut CharStream) -> Result { let innerx = match Number::parse(value) { Ok(innerx) if innerx == 69 => _innerx, Ok(innerx) if innerx == 420 => _innerx, Ok(innerx) => return Err(ParseError("Value was not one of the expected values.", value.position())), Err(error) => return Err(error) }; let _innercomma = Comma::parse(value)?; let _innery = Number::parse(value)?; Ok(Self { x: _innerx, comma: _innercomma, y: _innery}) }

fn span(&self) -> Span {
    Span::new(self.x.span().start, self.y.span().end)
}

}

[derive(Parsable)]

struct TestWhiteSpaceValue { #[whitespace(Indent)] #[value(69, 420)] x: Number, comma: Comma, y: Number }

// generated code impl Parse for Test { fn parse(value: &mut CharStream) -> Result { let _innerx = match { let _whitespacevalue = value.clone(); _whitespacevalue.set_whitespace(WhiteSpaceType::Indent);

        let inner = Number::parse(&mut __white_space_value);
        value.goto(__white_space_value.position())?;
        inner
    } {
        Ok(__inner_x) if __inner_x ==  69 => __inner_x,
        Ok(__inner_x) if __inner_x == 420 => __inner_x,
        Ok(__inner_x) => return Err(ParseError("Value was not one of the expected values.", value.position())),
        Err(error) => return Err(error)
    };
    let __inner_comma = Comma::parse(value)?;
    let __inner_y = Number::parse(value)?;
    Ok(Self { x: __inner_x, comma: __inner_comma, y: __inner_y})
}

fn span(&self) -> Span {
    Span::new(self.x.span().start, self.y.span().end)
}

} for enums it looks like this:rust

[derive(Parsable)]

enum Test { TestOne(tokens::Hyphen, Number), TestTwo { x: Number, y: Number } }

impl Test { fn parsetestone(value: &mut CharStream) -> Result { let _inner0 = tokens::Hyphen::parse(value)?; let _inner1 = Number::parse(value)?; Ok(Self::TestOne(inner0, _inner1)) } fn _parsetesttwo(&mut CharStream) -> Result { let _innerx = Number::parse(value)?; let _innery = Number::parse(value)?; Ok(Self::TestTwo(x: _innerx, y: _innery)) } }

impl Parse for Test { fn parse(value: &mut CharStream) -> Result { let mut options = Vec::new(); let mut error = None; let value = value.clone(); match _parsetestone(value) { Ok(inner) => { value.goto(value.position()); options.push(inner); } Err(err) => error = Some(err); }; let _value = value.clone(); match _parsetesttwo(value) { Ok(inner) => { value.goto(value.position()); options.push(inner); } Err(err) => error = Some(err); }; if options.len() > 0 { Ok(options.sortby(|a, b| a.span().partial_cmp(b.span()).unwrap())[0]) } else { Err(error.unwrap()) } }

fn span(&self) -> Span {
    match self {
        Self::TestOne(start, end) => Span::new(start.span().start, end.span().end),
        Self::TestTwo(x, y) => Span::new(x.span().start, y.span().end)
    }
}

} ``` The helper attributes for enums will work basically the same inside the helper functions as they did for structs. Therefore we do not need to think too much about their implementation right now (I hope...).