clippy::manual_clamp: Identifies good opportunities for a clamp function from std or core, and suggests using it

if input > max {
    max
} else if input < min {
    min
} else {
    input
}

input.max(min).min(max)

#[allow(clippy::manual_clamp)]
fn my_function() { /* ... */ }

[lints.clippy]
manual_clamp = "allow"

cargo clippy -- -A clippy::manual-clamp

Clippy's own documentation

What it does

Identifies good opportunities for a clamp function from std or core, and suggests using it.

Why is this bad?

clamp is much shorter, easier to read, and doesn’t use any control flow.

Limitations

This lint will only trigger if max and min are known at compile time, and max is greater than min.

Known issue(s)

If the clamped variable is NaN this suggestion will cause the code to propagate NaN rather than returning either max or min.

clamp functions will panic if max < min, max.is_nan(), or min.is_nan(). Some may consider panicking in these situations to be desirable, but it also may introduce panicking where there wasn’t any before.

See also the discussion in the PR.

Examples

if input > max {
    max
} else if input < min {
    min
} else {
    input
}

input.max(min).min(max)

match input {
    x if x > max => max,
    x if x < min => min,
    x => x,
}

let mut x = input;
if x < min { x = min; }
if x > max { x = max; }

Use instead:

input.clamp(min, max)

Configuration

• msrv: The minimum rust version that the project supports. Defaults to the rust-version field in Cargo.toml

  (default: current version)

From the Clippy lint list (0.1.99), part of the Rust project, MIT or Apache-2.0. Official entry.

Related lints

• too_many_argumentsChecks for functions with too many parameters
• clone_on_copyusing `clone` on type `u64` which implements the `Copy` trait
• type_complexityChecks for types used in structs, parameters and let declarations above a certain complexity threshold
• manual_abs_diffDetects patterns like if a > b { a - b } else { b - a } and suggests using a.abs_diff(b)
• manual_c_str_literalsChecks for the manual creation of C strings (a string with a NUL byte at the end), either through one of the CStr constructor functions, or more plainly by calling .as_ptr() on a (byte) string literal with a hardcoded \0 byte at the end
• manual_checked_opsDetects manual zero checks before dividing integers, such as if x != 0 { y / x }
• manual_div_ceilChecks for an expression like (x + (y - 1)) / y which is a common manual reimplementation of x.div_ceil(y)
• manual_filtermanual implementation of `Option::filter`
• manual_filter_map`filter(..).map(..)` can be simplified as `filter_map(..)`

All 847 Clippy lints · Rust compiler errors · Cargo.toml checker