Given `T` and `U` where `T extends U` how to return a `U`

Question

Given an API like:

class Bar { ... }
class Foo extends Bar { ... }

In Java's Optional type, we can say:

Optional<Foo> fooOption = ...
fooOption.orElse(aFoo) // returns something of type Foo

But, since Foo is a Bar, I would like to be able to say:

Optional<Foo> fooOption = ...
fooOption.orElse(aBar) // returns something of type Bar

As an exercise, I wanted to accomplish this with another type:

public abstract class Option<T> {
    // this doesn't compile
    public abstract <U super T> U orElse(U other);
}

How would I rewrite this to compile, but also support the ability to widen the type when desired at the same time?

Answer 1

But, since Foo is a Bar

But Bar is not a Foo. What I mean is that you can do this:

Optional<Bar> fooOpt = Optional.of(new Foo());
Bar bar = fooOpt.orElse(new Bar());

But you can't do the same thing with Optional<Foo> because it violates type constraints of Optional.orElse method.

In hypothetical implementation of Option<T> you should explicitly define U as a supertype of T

public class Option<U, T extends U> {
    T value;

    public U orElse(U other) {
        if (value != null) {
            return value;
        }
        return other;
    }
}

In that case you could wrote a code like this

Option<Foo, Bar> fooOpt = Option.of(new Foo());
Bar bar = fooOpt.orElse(new Bar());