推测嵌套静态泛型函数的泛型类型

Question

Java编译器是否能够从其上下文中推断泛型静态函数的类型作为另一个泛型静态函数的参数？

例如，我有一个简单的Pair类：

public class Pair<F, S> { 

    private final F mFirst; 

    private final S mSecond; 

    public Pair(F first, S second) { 
     mFirst = checkNotNull(first); 
     mSecond = checkNotNull(second); 
    } 

    public static <F, S, F1 extends F, S1 extends S> Pair<F, S> of(F1 first, S1 second) { 
     return new Pair<F, S>(first, second); 
    } 

    public F first() { 
     return mFirst; 
    } 

    public S second() { 
     return mSecond; 
    } 

    // ... 
} 

而且我有下面的一般静态函数：

public static <F, P extends Pair<F, ?>> Function<P, F> deferredFirst() { 
    return (Function<P, F>)DEFERRED_FIRST; 
} 

private static final Function<Pair<Object, ?>, Object> DEFERRED_FIRST = 
     new Function<Pair<Object,?>, Object>() { 

    @Override 
    public Object apply(Pair<Object, ?> input) { 
     return input.first(); 
    } 
}; 

哪我希望用如下（Collections2.transform is from Google Guava）：

List<Pair<Integer, Double>> values = ... 
Collection<Integer> firsts = Collections2.transform(values, 
     Pair.deferredFirst()); 

编译器抱怨到：

The method transform(Collection<F>, Function<? super F,T>) in the type 
Collections2 is not applicable for the arguments 
(List<Pair<Integer,Double>>, Function<Pair<Object,?>,Object>) 

因此，编译器似乎无法将transform（）推断的类型传播给deferredFirst（），因为它认为它们是对象。

强迫编译器了解类型通过以下两种方式运作：

Function<Pair<Integer, ?>, Integer> func = Pair.deferredFirst(); 
Collection<Integer> firsts = Collections2.transform(values, func); 


Collection<Integer> firsts = Collections2.transform(values, 
     Pair.<Integer, Pair<Integer, ?>>deferredFirst()); 

是否有可能改变任何一个函数的签名，让编译器推断/传播的类型？

编辑：对于波西米亚，这里是一个可能的方法上面的例子可以用于：

public static int sumSomeInts(List<Pair<Integer, Double>> values) { 
    Collection<Integer> ints = Collections2.transform(values, 
      Pair.deferredFirst()); 
    int sum = 0; 
    for(int i : ints) 
     sum += i; 
    return sum; 
} 

Answer 1

类型推断是讨厌和复杂的。他们必须在某个地方停下来。考虑

static <T> T foo(); 

String s = foo(); 

print(foo()) 

在分配方面，程序员的意图很明显，T应String

下一行，没有这么多。

print方法不是一个很好的例子，它是沉重的重载。假设print没有超载，其参数类型是固定的，所以T可以清楚地推断出来。编译器是否应该足够聪明以解决问题？

这听起来很合理，直到有人冒险阅读相关规范文本，15.12 Method Invocation Expressions好运气改变了那个烂摊子里的东西！

它太复杂了，即使编译器作者也不理解它。 javac和其他编译器中有大量的bug来源于这部分规范。

Answer 2

试试这个仿制药的功夫：

public static int sumSomeInts(List<Pair<Integer, Double>> values) { 
    Collection<Integer> ints = Collections2.transform(values, 
     Pair.<Integer, Double>deferredFirst()); 
    int sum = 0; 
    for(int i : ints) 
     sum += i; 
    return sum; 
} 

可以键入方法调用和将泛型传递给下一个呼叫。

我不确定这里使用的确切泛型参数，因为您没有包含足够的代码。如果你粘贴问题的整个方法，我将编辑这个答案，使其编译。 编辑：从问题的新信息

请让我知道它是否编译。如果不是这个解决方案，它会很接近。关键是使用Class.<Type>staticMethod()语法键入静态方法。

Answer 3

我就怎么了前一段时间是：

@SuppressWarnings("rawtypes") 
private static final Function ExtractFirst = new Function() { 
    @Override 
    public Object apply(final Object from) { 
     Preconditions.checkNotNull(from); 
     return ((Pair)from).first; 
    } 
}; 

@SuppressWarnings("unchecked") 
public static <A> Function<Pair<A,?>,A> extractFirst() { 
    return ExtractFirst; 
} 

不要让“SuppressWarnings”把你赶走，它工作正常。

例子：

List<Pair<String,String>> pairs = ImmutableList.of(Pair.of("a", "b"), 
    Pair.of("c", "d"),Pair.of("e", "f")); 
Iterable<String> firsts = Iterables.transform(pairs, 
    Pair.<String>extractFirst()); 

可惜的是，你必须在一般的参数提供给extractFirst（）。我认为这是你得到的最好的。