Consider the Iterator trait from the standard library:

pub trait Iterator {
    type Item;

    // required
    pub fn next(&mut self) -> Option<Self::Item>;

    // potentially advantageous to override
    pub fn size_hint(&self) -> (usize, Option<usize>) { ... }
    pub fn count(self) -> usize { ... }
    pub fn last(self) -> Option<Self::Item> { ... }
    pub fn advance_by(&mut self, n: usize) -> Result<(), usize> { ... }
    pub fn nth(&mut self, n: usize) -> Option<Self::Item> { ... }

    // convenience
    pub fn step_by(self, step: usize) -> StepBy<Self> { ... }
    pub fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> { ... }
    pub fn zip<U>(self, other: U) -> Zip<Self, U>::IntoIter> { ... }
    pub fn map<B, F>(self, f: F) -> Map<Self, F> { ... }
    pub fn for_each<F>(self, f: F) { ... }
    ...
}

And consider the Stream and StreamExt traits from the futures crate:

pub trait Stream {
    type Item;

    // required
    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>;

    // potentially advantageous to override
    fn size_hint(&self) -> (usize, Option<usize>) { ... }
}

pub trait StreamExt: Stream {
    // convenience
    pub fn next(&mut self) -> Next<'_, Self> { ... }
    pub fn into_future(self) -> StreamFuture<Self> { ... }
    pub fn map<T, F>(self, f: F) -> Map<Self, F> { ... }
    pub fn enumerate(self) -> Enumerate<Self> { ... }
    pub fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> { ... }
    ...
}

impl<T> StreamExt for T where T: Stream { ... }

They have a lot of similarities, given that Stream is essentially an async version of Iterator. However, I'd like to draw attention to their differences.

Why are they structured differently?

The only benefit I see of splitting a trait is that the StreamExt methods can't be overridden. This way they are guaranteed to behave as intended, whereas the convenience methods for Iterator could be overridden to behave inconsistently. However, I can't imagine this being a common issue to consider guarding against it. And this difference comes at the cost of accessibility and discoverability, requiring users to import StreamExt to use them and to know they exist in the first place.

Given that Stream came after Iterator it is obvious the split was a deliberate decision, but what was the motivation? Surely its more than what I've thought up. Is there something bad about the Iterator design?

^{Extension traits are certainly required when provided by another crate but this question isn't about that.}

回答