Having everything be const references is in a sense optimal, but is so prone to misuse that I wouldn't want it in the standard library. One option is to pass e

Having everything be const references is in a sense optimal, but is so prone to misuse that I wouldn't want it in the standard library. One option is to pass everything by value. Move semantics does the rest. Like: template<typename T> T clamp(T v, T lo, T hi) { if(v < lo) v = std::move(lo); if(v > hi) v = std::move(hi); return std::move(v); } For fundamental types, this is the same or better than before (including __int128_t and such). For bigint types with heap allocation, i.e., GMP wrappers and such, moving is fairly inexpensive (but for constant lo, hi, they need to be created/copied each time...). For fixed-width bigint types, moving is no different from copying and the cost is higher. In any case, the 99-percentile usage of these functions is with fundamental types, where pass-by-value is clearly the better choice. Alternatively, you could have template<typename T> T& clamp(T& v, T const& lo, T const& hi) { if(v < lo) v = lo; if(v > hi) v = hi; return v; } This forces the returned reference to be an l-value, and so returning dangling temporaries becomes more difficult. There's the added cost for the assignments, though.