Stable rustc 1.82 suggests using an unstable trait

[jaskij]

Code

use std::collections::HashSet;
use std::hash::Hash;
use num_traits::Bounded;

fn for_each_value_with_skip<T>(skipped: &HashSet<T>, func: impl Fn(T))
where
    T: Bounded + Hash + Eq,
{
    for v in T::min_value()..T::max_value() {
        if skipped.contains(&v) {
            continue;
        }
        func(v);
    }
}

Current output

error[E0277]: the trait bound `T: Step` is not satisfied
  --> s7-comm/src/tests/helpers.rs:11:14
   |
11 |     for v in T::min_value()..T::max_value() {
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Step` is not implemented for `T`, which is required by `std::ops::Range<T>: IntoIterator`
   |
   = note: required for `std::ops::Range<T>` to implement `Iterator`
   = note: required for `std::ops::Range<T>` to implement `IntoIterator`
help: consider further restricting this bound
   |
9  |     T: Bounded + Hash + Eq + std::iter::Step,
   |                            +++++++++++++++++

Desired output

No idea what the alternative is, if it's even possible to achieve what I want using stable Rust, but a stable compiler should not suggest using unstable features.

Rationale and extra context

No response

Other cases

Rust Version

$ rustc --version
rustc 1.82.0 (f6e511eec 2024-10-15)

Anything else?

Rust Playground

[jaskij]

That original code I posted can be further simplified, not sure if I should edit.

playground link

use num_traits::Bounded;

fn print_all<T>()
where
    T: Bounded,
{
    for v in T::min_value()..T::max_value() {
        println!("{v}");
    }
}

[estebank]

Further minimized:

trait Bounded {
    fn min_value() -> Self;
    fn max_value() -> Self;
}

fn print_all<T>()
where
    T: Bounded,
{
    for v in T::min_value()..T::max_value() {}
}

[clubby789]

I was typing this comment when the above appeared, but: further further minimized 😁

pub fn demo<T>(range: std::ops::Range<T>) {
    for _ in range {}
}

[cuviper]

No idea what the alternative is, if it's even possible to achieve what I want using stable Rust, but a stable compiler should not suggest using unstable features.

I don't know if the compiler could easily suggest this, but you can make your code work by adding where Range<T>: IntoIterator<Item = T>.

[jaskij]

thanks @cuviper , shepmaster helped me figure it out in the discord right after I made this issue

[estebank]

We currently don't suggest complex where clauses, only restricting type parameters or associated types. We could suggest where Range<T>: IntoIterator<Item = T> when T is a type parameter... I'll prototype to get a sense of how noisy that would be. Edit: It wouldn't necessarily be too common, but the filtering needed to make it so would likely require a bit of a refactor to note_obligation_cause_code...