try a method for matching delimiters

[koddsson]

How does this look? Is this correct? Should I peek and store that in a variable for performance? Or readability?

[koddsson]

This feels like this might be wrong but just let me know.

[keithamus]

Want to try building a more complex macro using match arms? I’m sure we have something similar in the existing macros.

[koddsson]

Want to try building a more complex macro using match arms? I’m sure we have something similar in the existing macros.

Sure! I'm not actually sure what that entails here.

[koddsson]

Want to try building a more complex macro using match arms? I’m sure we have something similar in the existing macros.

Sure! I'm not actually sure what that entails here.

Is it creating a macro that can be matched? Something that would enable this?

match token_kind_and_char!(token) {
  (Kind::Delim, '=') => todo!()
} 

[keithamus]

Want to try building a more complex macro using match arms? I’m sure we have something similar in the existing macros.

Sure! I'm not actually sure what that entails here.

Is it creating a macro that can be matched? Something that would enable this?

match token_kind_and_char!(token) {
  (Kind::Delim, '=') => todo!()
} 

Generally I'm trying to work towards a set of macros that take the shape of this:

expect_some_type!(parser.next());
expect_some_type!(parser.next(), some, details, about, the, type);

if match_some_type!(parser.next(), some, details, about, the, type) {
  // ...
}

match_some_type!{ parser, some, details, :
 foo => { /* ... */ }
 bar => { /* ... */ }
 baz => { /* ... */ }
}

In this way, we should write a match_delim! macro which allows those two types. So I'd expect match_delim!(parser.next(), '-') to be the equivalent of matches!(parser.next(), Token::Delim('-')). But I'd expect the following two blocks to also be equivalent:

match_delim!{ parser.next() :
  '=' => true,
  '>' => true,
  '<' => true,
  _ => false,
}

let token = parser.next();
match token.kind():
  Kind::Delim => match token.char() {
    '=' => true,
    '>' => true,
    '<' => true,
    _ => false,
  },
  _ => false,
}

You can see I have expect_ignore_case!, and match_ignore_case! (you can see this used in an if here and as a match block here). which represent this pattern. We have expect_delim!, so now we just need match_delim!.

match_ignore_case is defined here and it looks very complicated, but I think you could copy-paste this into a match_delim and tweak it. You won't need the Token::$tokenty bits as Delim is of course only one type.

[koddsson]

I feel like the formatting is all messed up here?

[keithamus]

Formatting is okay here.

[koddsson]

@keithamus: something like this? I'm noticing now that I don't have the .kind() check in here now. I still need that right? Should I do the match here for a tuple like I was doing earlier and always make sure that .kind() == Kind::Delim?

[keithamus]

Ideally it should check .kind() because .char() returns values for the other single character tokens like RightParen. In this particular case it's okay because we have a fallthrough to unexpected! but we should refine this later.

[keithamus]

Nice work!