java - 为什么这个与 lambda 相关的类型推断会失败？

Question

我想了解为什么以下内容似乎不应该与“引用不明确”一起使用。是否值得向 javac 团队报告？

import java.util.function.Function;
import java.util.function.ToLongFunction;
import org.junit.Test;

public class LambdaTest {

    @FunctionalInterface
    public static interface CheckedFunction<U,R>
    {
        R apply(U value) throws Exception;
    }

    @FunctionalInterface
    public static interface CheckedToLongFunction<T>
    {
        long apply(T i) throws Exception;
    }

    public static <T,R> Function<T,R> unchecked(CheckedFunction<T,R> func)
    {
        return value -> {
            try
            {
                return func.apply (value);
            }
            catch(RuntimeException e)
            {
                throw e;
            }
            catch(Exception e)
            {
                throw new RuntimeException(e);
            }
        };
    }

    public static <T> ToLongFunction<T> unchecked(CheckedToLongFunction<T> func)
    {
        return value -> {
            try
            {
                return func.apply (value);
            }
            catch(RuntimeException e)
            {
                throw e;
            }
            catch(Exception e)
            {
                throw new RuntimeException(e);
            }
        };
    }

      public void 
    bar( Function<Object,Object> fn ) { 

            System.out.println("Function"); 
        }

      @Test public void
    test() {

            bar (a -> a); //OK
            bar (unchecked (a -> a)); //Should be OK, but receive "reference to unchecked is ambiguous"
            bar (unchecked ((Object a) -> a)); //OK
        }

}

如您所见，该示例很有趣，因为 CheckedFunction 和 CheckedToLongFunction 都采用引用类型，因此显式指定 lamba 的输入类型似乎没有添加任何有用的内容。然而，它允许代码编译。

调用 unckeched(CheckedFunction) 应该没有歧义，因为 unchecked(CheckedToLongFunction) 产生一个返回原语的 lambda，而 bar 需要一个 Object.

我特别在寻找 JLS 的解决方案。如果 JLS 没有指定这一点，我可以尝试将其归档为 javac 错误。

Answer 1

你有两种方法

public static <T,R> Function<T,R> unchecked(CheckedFunction<T,R> func)
public static <T> ToLongFunction<T> unchecked(CheckedToLongFunction<T> func)

每个都有一个功能接口(interface)类型的参数。

@FunctionalInterface
public static interface CheckedFunction<U, R> {
    R apply(U value) throws Exception;
}

@FunctionalInterface
public static interface CheckedToLongFunction<T> {
    long apply(T i) throws Exception;
}

implicitly typed lambda expression给定适当的上下文，a -> a 可以应用于其中任何一个。但是，在进行重载解析时似乎并未检查该上下文。

所以虽然 a -> a 在

bar(unchecked(a -> a)); // Should be OK, but receive

无法转换为 CheckedToLongFunction 实例(因为无法从该调用上下文中推断出 Long 的类型参数)，lambda 仍然适用于函数类型。

编译器根本无法确定是否应该将 a -> a 转换为 CheckedToLongFunction 或 CheckedFunction。由于两者都适用，因此调用不明确。不检查调用上下文(和返回类型)来解决歧义。

然而，在这种情况下，

bar(unchecked((Object a) -> a)); // OK

我们有一个显式类型 lambda 表达式。 lambda 主体解析为 Object 类型的返回值，这不符合 CheckedToLongFunction#apply(..) 方法的要求，即。 Object 类型的表达式不能隐式转换为 long 类型的表达式。

因此，由于还有另一种适用方法，因此选择了该方法。