Any reason Iterator does not extend Iterable?

Question

This has been knawing at me for a few weeks now (like a spinter in my mind). Is there any reason Sun did not have Iterator extend Iterable in 1.5? It seems to me that the for-each loop would operate perfectly on an Iterator. Yet, since Iterator is in no way related to Iterable (which even from a linguistic standpoint seems downright odd), I can't do it. I did write the following:
public final class SimpleIterator<E> extends Object implements Iterable<E>, Iterator<E> {
     private final Iterator<E> nested;
     public SimpleIterator(final Collection<E> nested) {
          super();
          this.nested = Collections.unmodifiableCollection(nested).iterator();
     public final boolean hasNext() {
          return nested.hasNext();
     public final E next() {
          return nested.next();
     public final void remove() {
          throw new UnsupportedOperationException("SimpleIterator is immutable");
     public final Iterator<E> iterator() {
          return nested;
}But IMO the above seems like a hack. I have two questions:
Is the above safe (e.g., am I breaking some hidden rule in generics)?
Why didn't Sun have Iterator extend Iterable?- Saish

Answer 1

I think we should also consider that an Iterator has state. Generally when we talk about an Iterable we're referring to something like a Collection which may return an Iterator to iterate over the Collection. If Iterator implemented Iterable it would indeed be able to iterate, but not over itself and not even necessarily over the Collection (or whatever it is) that the Iterator was supposed to iterate over to begin with. Instead it would be relegated to iterating over something else and potentially only from the position where it started with a fun side effect of silently interfering with it's use elsewhere. My personal opinion is that aside from the fact that it just doesn't make much sense for an Iterator to be Iterable since the Iterator is not usually what's being iterated over to begin with, it would also likely lead to various annoying bugs when the same iterator is being iterated over in more than one place with little apparent benefit. After all, how often to you have a reference to an Iterator but not an Iterable where you want to use a for-each loop? I've never had that happen.
Besides all of that, it would break backward compatibility. Sun making mistakes elsewhere does not justify it here.