Generic trait for all containers implementing iter() - rust

Question

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!

Answer 1

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]