How can I display an enum in lowercase?

Question

I have an enum:

pub enum BoxColour {
    Red,
    Blue,
}

I not only want to get this value as a string, but I want the value to be converted to lower case.

This works:

impl Display for BoxColour {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.write_str(match self {
            BoxColour::Red => "red",
            BoxColour::Blue => "blue",
        })?;
        Ok(())
    }
}

When the list of colours grows, this list would need to be updated.

If I use the write! macro, it does not seem possible to manipulate the result because write! returns an instance of () instead of a String:

impl Display for BoxColour {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        write!(formatter, "{:?}", self)
    }
}

This suggests that this is working through side effects and maybe we could hack the same place in memory the value is going, but even if that is possible, it probably isn't a good idea...

write! returns an instance of () — it does not. It returns a fmt::Result, as shown by the return type of fmt. — Shepmaster
– Shepmaster, Commented Sep 1, 2021 at 14:06
...and fmt::Result is a type for Result<(), fmt::Error>. — loops
– loops, Commented Sep 1, 2021 at 14:07
You have already answered the question you have asked ("How can I Display an enum in lowercase?"). Please clarify exactly what it is you are asking beyond that. — Shepmaster
– Shepmaster, Commented Sep 1, 2021 at 14:07
The question you've linked to has an answer using strum, and strum allows you to customize what the Display format will be. It seems like you've linked to a suitable solution. — Shepmaster
– Shepmaster, Commented Sep 1, 2021 at 14:09
@Shepmaster, thanks for the response. @Smitop correctly understood my intention (below). Yes, I meant to indicate the success path for Result is () instead of String or something I might know how to work with. I saw strum, but couldn't get that to work either, but that's a question for a different day. — Brian Kessler
– Brian Kessler, Commented Sep 1, 2021 at 14:24

Kevin Reid · Accepted Answer · 2021-09-02 13:51:40Z

12

The strum crate provides a derive macro for implementing Display for an enum, and optionally lowercasing the variant names:

use strum_macros::Display;

#[derive(Display)]
// If we don't care about inner capitals, we don't need to set `serialize_all` 
// and can leave parenthesis empty.
#[strum(serialize_all = "snake_case")]
pub enum BoxColour {
    Red,
    Blue,
    LightGreen,  // example of how inner capitals are treated
}

fn main() {
    for c in [BoxColour::Red, BoxColor::Blue, BoxColor::LightGreen] {
        println!("{}", c);
    }
}

You will also need the corresponding dependency on strum in your Cargo.toml:

[dependencies]
strum = { version = "0.21", features = ["derive"] }

This should print:

red
blue
light_green

strum will generate code similar to the match with BoxColour::Red => "red", cases that you mentioned, but without the need to update it manually.

edited Sep 2, 2021 at 13:51

answered Sep 1, 2021 at 18:50

Kevin Reid

45.9k14 gold badges99 silver badges126 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Brian Kessler Over a year ago

Kevin Reid, Cheers for response. It didn't work "as-is", but I've fixed it. :-) Some might quibble about adding the dependency, but admittedly this is a bit more elegant than @Smitop's solution. I'm not sure whether Stackoverflow allows me to change the accepted answer, but I'll try. :-)

Stargateur Over a year ago

@BrianKessler you can change anytime you like accepted answer is just "that what I choice to fix my problem" hint for future reader, don't worry about that.

loops · Accepted Answer · 2021-09-01 14:11:37Z

8

Here is a way to do that without needing to manually update Display::fmt every time you add a new colour by using the derived Debug implementation and lowercasing that:

#[derive(Debug)]
pub enum BoxColour {
    Red,
    Blue,
}

impl fmt::Display for BoxColour {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        write!(formatter, "{}", format!("{:?}", self).to_lowercase())
    }
}

(playground)

Note that write! returns a Result<(), fmt::Error> (which is a fmt::Result), not a raw ().

But consider if it would just be better to manually update the list, or use a macro to specify that. Also consider how colours with multiple words (such as LightBlue) should be lowercased: is lightblue what you want there?

answered Sep 1, 2021 at 14:11

loops

5,9252 gold badges30 silver badges72 bronze badges

2 Comments

Stargateur Over a year ago

you format the argument you send to a formater ? that feel hacky and bad

loops Over a year ago

@Stargateur the code does seem hacky, but the nested format is the only way to make the Debug output lowercase: there isn't any format specifier for general lowercasing (LowerHex/LowerExp exists but are only applicable to formatting numbers).

Filipe Rodrigues · Accepted Answer · 2021-09-02 14:24:21Z

As an extension to @Smitop's answer, it is possible to generally display any value in lowercase by using a custom formatter, as such:

use std::fmt::{self, Write};

struct LowercaseFormatter<'a, 'b>(pub &'a mut fmt::Formatter<'b>);

impl<'a, 'b> fmt::Write for LowercaseFormatter<'a, 'b> {
    fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> {
        for ch in s.chars() {
            self.0.write_fmt(format_args!("{}", ch.to_lowercase()))?;
        }
        
        Ok(())
    }
}

Then use it as such:

#[derive(Debug)]
pub enum BoxColour {
    Red,
    Blue,
}

impl fmt::Display for BoxColour {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        write!(LowercaseFormatter(formatter), "{:?}", self)
    }
}

fn main() {
    println!("{}", BoxColour::Red); // "red"
}

Playground

This version doesn't allocate a string on every formatting, but it is also not very optimized, calling write_fmt for every character is relatively costly.

One alternative for just ascii characters, is to call write_char(ch.to_ascii_lowercase()), but writing a string a character at a time is also relatively costly.

A proper solution would partition the string in some way to be able to write all already lowercase characters all at once, and only special case the uppercase ones.

Gabriel Stoica · Accepted Answer · 2025-09-30 13:21:23Z

0

Or simply use serde and set the rename_all attribute to lowercase like this:

#[derive(Serialize)]
#[serde(rename_all = "lowercase")]
enum BoxColour {
    Red
    Blue
}

edited Sep 30 at 13:21

answered Sep 30 at 13:06

Gabriel Stoica

1031 silver badge6 bronze badges

1 Comment

Chayim Friedman Sep 30 at 13:12

You forgot the #[derive(Serialize)]. Also, serde is much heavier than strum, and requires a serializer crate as well. So, unless you already use it, better use strum.

Collectives™ on Stack Overflow

How can I display an enum in lowercase?

4 Answers 4

2 Comments

2 Comments

Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

2 Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related