What does Rhs refer to in a compiler error message about PartialEq? - iterator

Question

I am trying to create a function that takes two iterators as as parameters and iterates over the items by reference. Each Iterator item should implement PartialEq.
My first attempt was:
fn compute<T: Iterator>(first: T, second: T, len: usize) -> usize
where
T::Item: std::cmp::PartialEq,
{
// ...
}
This compiles but iterates (as far as I understand) not by reference but by value and the compiler complains about a move when iterating.
My second attempt was something like:
fn compute<'a, T>(first: T, second: T, len: usize) -> usize
where
T: Iterator<Item = &'a std::cmp::PartialEq>,
{
//...
}
resulting in a compiler error:
error[E0393]: the type parameter `Rhs` must be explicitly specified
--> src/main.rs:3:28
|
3 | T: Iterator<Item = &'a std::cmp::PartialEq>,
| ^^^^^^^^^^^^^^^^^^^ missing reference to `Rhs`
|
= note: because of the default `Self` reference, type parameters must be specified on object types
What does the Rhs (Right hand side?) the compiler refers to here mean? Why do I need a reference to it? How do I pass a bounded reference-based Iterator into a function?

Answer 1

PartialEq is a trait that allows you to compare two values. Those two values do not have to be of the same type! The generic type Rhs is used to specify what type we are comparing with. By default, the value of Rhs is the same as the type that is being compared to:
pub trait PartialEq<Rhs = Self>
where
Rhs: ?Sized,
In this case, you are actually requesting that the iterator value be the trait object &PartialEq. As the error message states:
because of the default Self reference, type parameters must be specified on object types
We could specify it:
fn compute<'a, T>(first: T, second: T, len: usize) -> usize
where
T: Iterator<Item = &'a std::cmp::PartialEq<i32>>,
or
fn compute<'a, T: 'a>(first: T, second: T, len: usize) -> usize
where
T: Iterator<Item = &'a std::cmp::PartialEq<&'a T>>,
but iterates (as far as I understand) not by reference but by value
It's quite possible for it to iterate by reference. Remember that T is any type and that i32, &i32, and &mut i32 are all types. Your first example is the formulation of the signature I would use:
fn compute<T: Iterator>(first: T, second: T, len: usize) -> usize
where
T::Item: std::cmp::PartialEq,
{
42
}
fn main() {
let a = [1, 2, 3];
let b = [4, 5, 6];
compute(a.iter(), b.iter(), 1);
compute(a.iter(), b.iter(), 2);
compute(a.iter(), b.iter(), 3);
}