Implementing (and then using from a system) fmt::Display for a struct deriving Bundle or QueryData?

[bschnur]

Please bear with me, I'm new to Rust and Bevy.

I want to print information about an entity without specifying the format at length every time. Hence, I'm looking to implement fmt::Display.

As my first attempt, I've written the implementation for the struct-deriving-from-Bundle that I used to create the entity (and its peers) - and have additionally written the implementation for the enum type of one of its contained fields - but I realize now that this is probably not what I am after - by the time I want to print the information, I am interacting not with a bundle (IIUC) but rather a permutation of a Query generic subtype - say, Query<Entity, &MyComponent1, &MyComponent2>.

Is the straightforward answer to instead (or additionally) implement fmt::Display for a corresponding QueryData? (The immediate challenge I'm envisioning with said approach is: how do I deal with cases where I want to query different subsets of the entity's components, without having to re-implement fmt::Display for each combination?)

Maybe there is a different approach - perhaps involving the Entity type or some kind of cast - of which I'm unaware?

Code for flavor/visual, for those interested (the most relevant portion is at the bottom - additional lines included for context in case desired):

// Declaration of components and implementation of enum Display:

#[derive(Component, Debug)]
struct Text(String);

#[derive(Component, Debug)]
struct FontColor(Color);

#[derive(Component, Debug)]
struct BkgColor(Color);

#[derive(Debug, PartialEq, Eq)]
enum HDir { LEFT, RIGHT, }
#[derive(Component, Debug)]
struct Side(HDir);

impl fmt::Display for HDir {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		write!(f, "{}", match self {
			HDir::LEFT => { "LEFT" },
			HDir::RIGHT => { "RIGHT" },
		})
	}
}

#[derive(Component, Debug, PartialEq, Eq)]
struct Index(usize);

// Resource used for setting the last of the above components:

#[derive(Resource)]
struct SentMessageNextIndex(usize);
impl Default for SentMessageNextIndex {
	fn default() -> Self {
		Self(0)
	}
}

// The struct derviing from Bundle
// and its corresponding Display implementation:

#[derive(Bundle, Debug)]
struct SentMessage {
	text: Text,
	font_color: FontColor,
	bkg_color: BkgColor,
	side: Side,
	index: Index,
}
impl fmt::Display for SentMessage {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		let font_srgba = self.font_color.0.to_srgba();
		let bkg_srgba = self.bkg_color.0.to_srgba();
		write!(
			f,
			"\"{}\"\nFont Color: ({}, {}, {}, {})\nBkg Color: ({}, {}, {}, {})\nSide: {}\nIndex: {}",
			self.text.0,
			font_srgba.red, font_srgba.blue, font_srgba.green, font_srgba.alpha,
			bkg_srgba.red, bkg_srgba.blue, bkg_srgba.green, bkg_srgba.alpha,
			self.side.0,
			self.index.0,
		)
	}
}

// ... snip snip...

// A system wherein I'd like to display information about the relevant Entity:

fn sandbox_update(
	mut dark_mode_enabled: ResMut<DarkModeEnabled>,
	// msgs: Query<(Entity, &Text, &FontColor, &BkgColor, &Side)>,
	msgs: Query<(Entity, &Text, &FontColor, &BkgColor, &Side)>,
	mut commands: Commands
) {
	// for (id, text, color, bkg, side) in &msgs {
	for msg in &msgs {
		// println!("\nText: {}\nFontColor: {:#?}\nBkgColor: {:#?}\nScreenSide: {:?}", text.0, color.0, bkg.0, side.0);
		println!("\n{}", msg); // msg gets squiggles for not implementing Display
	}
}

[bschnur]

It seems to me like maybe I should stick to implementing Display on individual components that need them, and if I want to avoid repetition when printing information, pass components into a utility function - perhaps with some parameters optional - and write to e.g. stdout from there.