Sometimes we allocate when implementing Display where we do not need to, for example by using format! which will create a String which is heap allocated.
This can be undesirable for users and may negatively impact performance.

Display is the "Format trait for an empty format, {}.". Anywhere "{our_type}" is found, the our_type's Display::fmt() is called,
to create or add to a Formatter of the caller.

In almost all instances we could:

enum State {
    SomeState,
   SomeOtherState,
    ...
}

impl fmt::Display for State {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
           let sring_slice = match self {
           SomeState => "some state",
           SomeOtherState => "some other state",
           _ => "unknown state",
           };
           f.write_str(string_slice)
    }
}

As far as I understood, Formatter::write_str will not allocate unless the string slice is atypically large (I've read over 4Kb somewhere, 8Kb elsewhere).

If we do want to compose in our Display implementations, we can do without format! by using use format_args! on a stack allocated [u8] buffer instead and write! that buffer to the Formatter and avoid necessity of allocating during formatting.