Wsrtjtyk

I'm trying to find the correct generics and wildcard arrangement to make this work. The types have been changed and all other code has removed to keep this as simple as possible.

Here I have a generic class with an upper bound of Number that implements Iterable. It contains a List of the generic type.

I want to pass in a List of any Number subclass, and return the Iterator of that type from the List field.

Here's the basic idea that obviously doesn't work.

class GenericQuestion<T extends Number> implements Iterable<T> {

    List<T> numbers;



    GenericQuestion(List<T> number) {

        this.numbers = number;

    }



    public Iterator<T> iterator() {

        return numbers.iterator();

    }



    static void main() {

        for (Number n : new GenericQuestion<Number>(new ArrayList<Integer>())) { // <---- error

            System.out.println(n.byteValue());

        }

    }

}

This give the expected error

incompatible types: ArrayList<Integer> cannot be converted to List<Number>

Upper-bounded wildcards to the rescue! Almost...

class GenericQuestion<T extends Number> implements Iterable<T> {

    List<? extends T> numbers;



    GenericQuestion(List<? extends T> number) {

        this.numbers = number;

    }



    public Iterator<T> iterator() {

        return numbers.iterator(); // <----- error

    }



    static void main() {

        for (Number n : new GenericQuestion<Number>(new ArrayList<Integer>())) {

            System.out.println(n.byteValue());

        }

    }

}

Now I'm getting hung up on the iterator types conflicting.

incompatible types: Iterator<CAP#1> cannot be converted to Iterator<T>

  where T is a type-variable:

    T extends Number declared in class GenericQuestion

  where CAP#1 is a fresh type-variable:

    CAP#1 extends T from capture of ? extends T

Now logically I'm pretty sure it would be perfectly safe to just force cast the returned iterator to type (Iterator<T>),
but I'd rather do this the "right" way. I've tried all sorts of things. Here was another desperate attempt that still didn't work.

class GenericQuestion<T extends Number> implements Iterable<T> {

    List<T> numbers;



    <U extends Number> GenericQuestion(List<U> number) {

        this.numbers = number; // <----- error

    }



    public Iterator<T> iterator() {

        return numbers.iterator();

    }



    static void main() {

        for (Number n : new GenericQuestion<Number>(new ArrayList<Integer>())) {

            System.out.println(n.byteValue());

        }

    }

}

The error.

incompatible types: List<U> cannot be converted to List<T>

  where U,T are type-variables:

    U extends Number declared in constructor <U>GenericQuestion(List<U>)

    T extends Number declared in class GenericQuestion

I thought maybe a helper function could bridge the gap, but didn't have any luck with my attempts.

This doesn't seem like it should be so hard. Is force casting really the way to go? Or is there a generic declaration that will make this all work together?

I think you must have some type unsafe code somewhere if you want variance on T.

The thing that causes this limitation is Iterable<T>. It requires a method Iterator<T> iterator(). You can't be certain that your Iterator<? extends T> can be converted to Iterator<T> because the only case in which this is possible is when your Iterator<? extends T> is a Iterator<T> at runtime. You probably already understand the fact that A<T> cannot be converted to A<U> even if T extends U.

If instead you created your own MyIterable<T> interface, you can do this:

class GenericQuestion<T extends Number> implements MyIterable<T> {

    List<? extends T> numbers;



    GenericQuestion(List<? extends T> number) {

        this.numbers = number;

    }



    public Iterator<? extends T> iterator() {

        return numbers.iterator();

    }



    static void main() {

        GenericQuestion<Number> q = new GenericQuestion<>(new ArrayList<Integer>());

        Iterator<? extends Number> iter = q.iterator();

        System.out.println(iter.next().byteValue());

    }

}



interface MyIterable<T> {

    Iterator<? extends T> iterator();

}

But as you can see, you can't use MyIterable with a for loop.

Therefore, you either don't allow new GenericQuestion<Number>(new ArrayList<Integer>()), or you write type unsafe code.

A litle change to your test so that it is not trying to force to GenericQuestion<Number> (but to let infer type instead):

for (Number n : new GenericQuestion<>(new ArrayList<Integer>())) {

Also you could change the declaration for the List type of iterable, like:

class GenericQuestion<T extends Number, L extends List<T>>

        implements Iterable<T> {



    private L numbers;



    GenericQuestion(L number) {

        this.numbers = number;

    }

Another solution I found was to wrap the wildcard iterator with an iterator of the base type. I suspect this is technically how you're supposed to handle this situation.

class GenericQuestion<T extends Number> implements Iterable<T> {

    List<? extends T> numbers;



    GenericQuestion(List<? extends T> number) {

        this.numbers = number;

    }



    public Iterator<T> iterator() {

        return new Iterator<T>() {

            Iterator<? extends T> iter = numbers.iterator();

            public boolean hasNext() {

                return iter.hasNext();

            }



            public T next() {

               return iter.next();

            }



            public void remove() {

                iter.remove();

            }

        };

    }



    static void main() {

        for (Number n : new GenericQuestion<Number>(new ArrayList<Integer>())) {

            System.out.println(n.byteValue());

        }

    }

}