Generic trait for all containers implementing iter()

I'm trying to implement a trait for all containers that implement iter(), ie. for all containers that provide an IntoIterator<Item=&'a T>. I've tried this, but unfortunately, even for the simplest case it is failing. Maybe someone knows what I'm doing wrong?

trait Monotonic<'a, T: 'a + ?Sized> {
    fn is_monotonic(&mut self) -> bool {
	return true;
    }
}

impl<'a, T: 'a + ?Sized, C> Monotonic<'a, T> for C
where C: IntoIterator<Item=&'a T> + ?Sized {}


fn main() {
    let v = vec![1u32, 2u32, 3u32];
    if v.is_monotonic() {
	print!("Is monotonic!");
    }
}

The compiler complains about not satisfied bounds:

error[E0599]: the method `is_monotonic` exists for struct `Vec<u32>`, but its trait bounds were not satisfied
  --> src/test.rs:13:10
   |
13 |     if v.is_monotonic() {
   |          ^^^^^^^^^^^^ method cannot be called on `Vec<u32>` due to unsatisfied trait bounds
  --> /rustc/fc594f15669680fa70d255faec3ca3fb507c3405/library/alloc/src/vec/mod.rs:400:1
   |
   |   = note: doesn't satisfy `<Vec<u32> as IntoIterator>::Item = &_`
  
 = note: doesn't satisfy `Vec<u32>: Monotonic<'_, _>`
   |
note: trait bound `[u32]: IntoIterator` was not satisfied
  --> src/test.rs:8:10
   |
7  | impl<'a, T: 'a + ?Sized, C> Monotonic<'a, T> for C
   |                             ----------------     -
8  | where C: IntoIterator<Item=&'a T> + ?Sized {}
   |          ^^^^^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound introduced here
note: the following trait bounds were not satisfied:
      `<Vec<u32> as IntoIterator>::Item = &_`
      `<[u32] as IntoIterator>::Item = &_`
  --> src/test.rs:8:23
   |
7  | impl<'a, T: 'a + ?Sized, C> Monotonic<'a, T> for C
   |                             ----------------     -
8  | where C: IntoIterator<Item=&'a T> + ?Sized {}
   |                       ^^^^^^^^^^ unsatisfied trait bound introduced here

error: aborting due to previous error

For more information about this error, try `rustc --explain E0599`.

I've already tried to solve this on my own, but after several attempts I'm at a point where some help would be highly appreciated!

According to its documentation, Vec<T> implements the following IntoIterator traits:

• IntoIterator<Item = &'a T> for &'a Vec<T, A>
• IntoIterator<Item = &'a mut T> for &'a mut Vec<T, A>
• IntoIterator<Item = T> for Vec<T, A>

The variable v you are calling it on is a Vec<u32>, which only implements IntoIterator<Item = u32>, and not any kind of &'a u32 as your trait requires.

There are a couple of solutions. The first one is to run the code on &v:

trait Monotonic<'a, T: 'a + ?Sized> {
    fn is_monotonic(&mut self) -> bool {
        return true;
    }
}

impl<'a, T: 'a + ?Sized, C> Monotonic<'a, T> for C where C: IntoIterator<Item = &'a T> + ?Sized {}

fn main() {
    let v = vec![1u32, 2u32, 3u32];
    if (&v).is_monotonic() {
        print!("Is monotonic!");
    }
}

Although that's probably not what you want, because I read from your question that you want your Monotonic trait to be implemented as generically as possible. For that, simply remove the & requirement:

trait Monotonic<'a, T: 'a + ?Sized> {
    fn is_monotonic(&mut self) -> bool {
        return true;
    }
}

impl<'a, T: 'a + ?Sized, C> Monotonic<'a, T> for C where C: IntoIterator<Item = T> + ?Sized {}

fn main() {
    let mut v = vec![1u32, 2u32, 3u32];
    if v.is_monotonic() {
        print!("Is monotonic!");
    }
}

Couple of remarks concerning your current code structure, though:

• While this technically compiles, it won't be possible to implement your function. IntoIterator consumes the object you call it on, but your is_monotonic function only has &mut access to it, so you won't ever be able to call into_iter here.

  What you probably want instead is to have is_monotonic consume the value, but then only implement it for &T.

• Your Monotonic function doesn't require any generic parameters, so remove them.

trait Monotonic {
    fn is_monotonic(self) -> bool;
}

impl<'a, T, C> Monotonic for &'a C
where
    &'a C: IntoIterator<Item = T>,
{
    fn is_monotonic(self) -> bool {
        let mut iter = self.into_iter();

        // Do something with iter
        let x = iter.next().unwrap();

        // Return result
        true
    }
}

fn main() {
    let v = vec![1u32, 2u32, 3u32];
    if v.is_monotonic() {
        print!("Is monotonic!");
    }
}

Here is an example implementation of is_monotonic, assuming it means monotonic rising:

trait Monotonic {
    fn is_monotonic(self) -> bool;
}

impl<'a, T, C> Monotonic for &'a C
where
    &'a C: IntoIterator<Item = T>,
    T: PartialOrd,
{
    fn is_monotonic(self) -> bool {
        let mut iter = self.into_iter();

        if let Some(first) = iter.next() {
            let mut previous = first;
            for next in iter {
                if !next.ge(&previous) {
                    return false;
                }
                previous = next;
            }
            true
        } else {
            // An iterator without elements is monotonic.
            // Although that's probably up for philosophical debate.
            true
        }
    }
}

fn main() {
    let v = vec![1u32, 2u32, 3u32];
    if v.is_monotonic() {
        println!("Is monotonic!");
    }
    println!("{:?}", v);
}

Is monotonic!
[1, 2, 3]