let range = std::ops::RangeInclusive<u8> = 1..=100;
let value_raw = 200;
let vaue_within_range = if range.contains(&value_raw) { value_raw } else { 1 };
//Assume value is safely within the intended range from this point onwards

I feel like if range.contains(&value_raw) { value_raw } else { 1 } is already pretty short. If you need this a lot, make your own function

If you wanted to take either the minimum or the maximum as default, depending on whether the value lies below or above the range, using Ord::clamp would be an option.

Totally missed the existence of clamp . Is there something similar that takes a range as the min/max bounds? Or I guess I could just use value.clamp(range.min(), range.max()).

Clamping to a (half-)open range doesn't make sense when the underlying type is "continuous" (=floating point, for the lack of a better representation). A continuous (half-)open range lacks a minimum and/or a maximum, so when the value is <= infimum or >= supremum, there's no value inside the range to return.

One could use the infimum and the supremum instead, but the returned value not being contained in the range is very confusing. Alternatively, the operation could be defined for discrete types only, but that's 1. surprising in a bad way, and 2. laborious to do generically (it would require something like a new Discrete trait).

Because floating-point isn't actually continuous, it would be possible to have PI.clamp(0.0_f32 .. 1.0) => 0.99999994_f32 (0x3F7FFFFF) as that's the largest representable value below one.

But

is very true, and the big reason why std's clamp didn't even try that.

Sure thing! However, I'd actually argue that it's conceptually not the right thing to do, even if technically possible. Floats are much more often used as an approximation to real numbers, and not completely accurately as they are, base-2 rational numbers with scientific notation.