在不失泛型的情况下包装逆变函数接口

Question

interface Func<A> {
    double apply(Optional<A> a);
}

class Foo {
    public double compute(Func<Double> f) {
        // Sometimes amend the function to do something slightly different
        Func<Double> g = f;
        if (someCondition())
            g = oa -> Math.max(0, f.apply(oa));

        return g.apply(Optional.of(3.14)) + g.apply(Optional.empty());
    }
}

    public double compute(Func<? super Double> f) {
        Func<? super Double> g = f;
        if (someCondition())
            g = oa -> Math.max(0, f.apply(oa));
        ...

将F本身赋值给G似乎并不让编译器担心，而且如果apply的参数是a而不是option时，也不会出现问题。

不幸的是，似乎没有一种方法来命名？super double参数类型，这样我就可以再次将其用作G的类型和/或用一个老式的内部类替换lambda。

例如，这在语法上甚至是不允许的：

    public <T super Double> double compute(Func<T> f) {
        Func<T> g = f;
        ...

    public double compute(Func<? super Double> f) {
        if (someCondition())
            return computeInner(oa -> Math.max(0, f.apply(oa)));
        else
            return computeInner(f);
    }

    private double computeInner(Func<? super Double> g) {
        return g.apply(Optional.of(3.14)) + g.apply(Optional.empty());
    }

编译器接受这一点，但出于让类型检查器高兴的原因而进行的间接调用并不是我所说的真正优雅的调用。

Answer 1

试试这个奇怪的把戏：

g = oa -> Math.max(0, f.apply(oa.map(a -> a)));
                             // ^----------^

像这样映射可选对象的类型允许编译器将可选对象的类型“强制转换”为一致的类型。

IdeOne演示