Which BiPredicate Lambda Declaration Using var Is Valid?

Why the Answer Is Correct

B is valid because both lambda parameters are declared with var inside the mandatory parentheses: BiPredicate testEquality = (var x, var y) -> (x.equals(y));. JLS 15.27.1 states that if one lambda parameter is declared with var, then all parameters must be declared with var, and the parameter list must remain parenthesized. Here the target type is the raw BiPredicate, so the function type is erased and the inferred parameter types are Object, which makes x.equals(y) a legal invocation. No rules on mixing, missing parentheses, or inferred types are violated, so B compiles cleanly.

Why the Other Options Are Wrong

A mixes var x with the explicit type Integer y in the same parameter list, which JLS 15.27.1 explicitly forbids — you must either use var everywhere or explicit types everywhere. C drops the parentheses (var x, var y ->...), and an implicitly typed or var-typed lambda parameter list must always be enclosed in parentheses, so this is a syntax error. D mixes var x with the implicitly typed parameter y, which is the same all-or-nothing violation as A but in the opposite direction: once var appears, every parameter needs var. None of A, C, or D can be compiled, while B is the only declaration that satisfies every lambda parameter rule.

Community Comment Notes

ASPushkin reasoned through the same rule set, stating that in A "there is no mix var with the explicit types", that B is fine, and that C is a "syntax error without brackets". Another learner noted that D is a compound form that is not allowed, which matches the all-or-nothing var requirement. d7bb0b2 also chose B, adding that because the BiPredicate variable is declared without type arguments, the parameters resolve to Object rather than a specific type. A third commenter simply cross-referenced this item as similar to numbered questions 22 and 204 seen previously, suggesting the var-lambda rule recurs on the exam.