java - 为什么这个 Java lambda 表达式参数有错误？

Question

这是一个使用解释器 GOF 模式的算术表达式求值器，BinaryOp 是一个非终结符表达式。

public class BinaryOP<T> implements Expression<T> {

    private Expression<T> e1;
    private Expression<T> e2;
    private BiFunction<Expression<T>, Expression<T>, T> f;

    public BinaryOp(Expression<T> e1, Expression<T> e2, 
            BiFunction<Expression<T>, Expression<T>, T> f){
        this.e1 = e1; this.e2 = e2; this.f = f;
    }

    @Override
    public <T> T interpret(IContext context){
        return (T)f.apply(e1, e2);
    }
}

变量是终端表达式。

public class Variable<T> implements Expression<T> {     
    private T v;

    public Variable(T v){
        this.v = v;
    }

    @Override
    public <T> T interpret(IContext context){
        return (T)context.recognize(v);
    }
}

定义 BiFunction sum 时，如果 a 和 b 是表达式类型且结果返回整数，则使用 lambda 时会出现错误，其参数会出现错误，为什么会出现此错误？

public class AritmeticInterpreter
{
    public static void main(String[] args) {    
    IContext<Integer> ctxArimetic = value -> value;

    BiFunction<Expression<Integer>, Expression<Integer>, Integer> sum
    //Error = incompatible types: incompatible parameter types in lambda expression                                       
                = (a, b, result) -> {
                return (Integer)a.interpret(ctxArimetic) + (Integer)b.interpret(ctxArimetic);
           };
    }
}

是什么导致了这个错误，返回类型必须是另一个表达式吗？如果我将解释方法返回类型更改为表达式，我将无法像这样对两个表达式 a 和 b 求和:

(a, b) -> a + b

因为它们不是整数。

好吧，这不是标题的一部分，但是，我可以摆脱对方法的强制转换解释吗？我知道 java 编译器会删除泛型类型，但是，有办法吗？

更新:

这是表达式接口(interface)。

public interface Expression<T> {

     public <T> T interpret(IContext context);

}

Answer 1

根据 JB Nizet 评论和此 example我发现我只需要在 lambda 中使用 a 和 b 作为参数。

这是正确的代码。

public static void main(String[] args) {

    IContext<Integer> ctxArimetic = value -> value;     

    BiFunction<Expression<Integer>, Expression<Integer>, Integer> sum
            = (a, b) -> {
        return a.interpret(ctxArimetic) + b.interpret(ctxArimetic);
    };

}

最后一个问题。

在 BinaryOP 类上我进行了此更改:

@Override
public T interpret(IContext<T> context){
        return f.apply(e1, e2);
}

在表达式界面上:

public interface Expression<T> {

       public T interpret(IContext<T> context);

}

这个错误是因为我参数化了解释方法，这允许该方法返回任何对象。我记得编译器输出错误“T#2 与类型 T#1 不同”，T#2 是解释方法上的泛型参数 ，而 T#1 是 BinaryOp 类上的泛型类型。

我不知道如何正确使用 lambda 和泛型。

更新:修复一些错误，我改变了

public T interpret(IContext context);

至

public T interpret(IContext<T> context);