Implement TryStableInterpolate.

[viridia]

Fixes: #20579

Testing

• Doc test
• Also tested extensively in a separate repo, however that code was not carried over (yet).

Note: Because docs.rs was down, I could not validate the doc link urls.

[viridia]

@LikeLakers2 Tried to add you as a reviewer but could not for some reason.

[LikeLakers2]

No worries. I hope I didn't frustrate you too much in the issue you made!

[LikeLakers2]

Huh, so this ended up working? I'm curious what was different about how you initially tested it, that caused the error you were reporting.

[viridia]

I think it has to do with the fact that the impls are in the same module as the target types instead of being in the same module as the trait definition. But to be honest, I'm not really sure why it works.

[github-actions]

Your PR caused a change in the graphical output of an example or rendering test. This might be intentional, but it could also mean that something broke!
You can review it at https://pixel-eagle.com/project/B04F67C0-C054-4A6F-92EC-F599FEC2FD1D?filter=PR-21633

If it's expected, please add the M-Deliberate-Rendering-Change label.

If this change seems unrelated to your PR, you can consider updating your PR to target the latest main branch, either by rebasing or merging main into it.

[LikeLakers2]

Just a couple more nitpicks. These ones could reasonably be skipped if desired.

[LikeLakers2]

You'll probably want to impl Error for MismatchedUnitsError. Error requires Display also be implemented, so I'll also include such an impl here:

impl core::error::Error for MismatchedUnitsError {}

impl core::fmt::Display for MismatchedUnitsError {
	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
		write!(f, "cannot interpolate between two values of different units")
	}
}

[LikeLakers2]

I really appreciate the extensive documentation here, but now that the error type can be customized by the user, I do think it focuses a bit too much on mismatched units.

Here's how I might rewrite this documentation:

/// A type with a natural interpolation that provides strong subdivision guarantees, similar to
/// [`StableInterpolation`], but which cannot be guaranteed to interpolate correctly between two
/// arbitrary values.
///
/// The motivating case for this trait is animating UI entities with [`Val`] properties. Because
/// different `Val` instances may be of different incompatible variants, there is no guarantee that
/// we can be interpolate between two `Val`s. The same concept can be extended to other types as
/// well.
///
/// Bevy's default animation system handles erroring interpolations by snapping to the new value
/// without interpolating.
///
/// [`Val`]: https://docs.rs/bevy/latest/bevy/ui/enum.Val.html

It's not a perfect rewrite, and could probably use some work, but I hope it helps.

[LikeLakers2]

However, putting aside those nitpicks, I think this PR looks good. So this gets my approval.