A set of derive macros that automatically implement Display
and Debug
for an enum, based on the Logos token
and regex
attributes.
Simply use logos_display::Display
and/or use logos_display::Debug
and add it to your derives, like so:
```rust use logos_display::{Display, Debug}
enum A { #[token("{")] LCur,
#[regex("[a-z]")]
Lower
}
| V
impl std::fmt::Display for A { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let ret = match &self { A::LCur => "{", A::Lower => "[a-z]", }; write!(f, "{}", ret) } } ```
Display
and Debug
If the enum variant is a unit type, there is no difference. But in the case where the variant is a tuple or struct variant, the Debug
version will also show the inner value held by the instance, whereas the Display
version will only output the name of the outer layer. Like so:
```rust use logos_display::{Display, Debug}
enum A { #[token("{")] LCur,
#[regex("[a-z]", |lex| some_func(lex.slice()))]
Lower(TypeOne, TypeTwo)
}
| V
impl std::fmt::Debug for A { fn fmt(&self, f: &mut std::fmt::Formatter<'>) -> std::fmt::Result { let ret = match &self { A::LCur => "{", A::Lower(arg1, arg2) => format!("{}{:?}", "[a-z]", vec![arg1, _arg2]), }; write!(f, "{}", ret) } } ```
This does of course require the inner types to implement Debug
in some form as well.
In the case that a variant is not a token or regex, the name of the variant will be used for the Display method (so variant B
will have "B"
as it's string representation). If you want to override any of this functionality, you can add an display_override("string")
attribute to the variant as follows:
```rust use logos_display::Display
enum A { #[display_override("fancy curly thing")] #[token("{")] LCur,
#[regex("[a-z]")]
Lower
}
| V
impl std::fmt::Display for A { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let ret = match &self { A::LCur => "fancy curly thing", A::Lower => "[a-z]", }; write!(f, "{}", ret) } } ```
When a variant accepts multiple tokens, by default, they will be concatenated using /
in the string representation, like so:
```rust use logos_display::Display
enum A { #[token("{")] #[token("}")] Cur }
| V
impl std::fmt::Display for A { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let ret = match &self { A::LCur => "{/}", }; write!(f, "{}", ret) } } ```
This functionality can be overwritten using the display_concat("string")
attribute on the original enum:
```rust
use logos_display::Display
enum A { #[token("{")] #[token("}")] Cur }
| V
impl std::fmt::Display for A { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let ret = match &self { A::LCur => "{ or }", }; write!(f, "{}", ret) } } ```
Additionally, you can pass None
to this attribute in order to disable concatonation. In this case, the token that is encountered last will be used:
```rust
use logos_display::Display
enum A { #[token("{")] #[token("}")] Cur }
| V
impl std::fmt::Display for A { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let ret = match &self { A::LCur => "}", }; write!(f, "{}", ret) } } ```