Why is a cast performed against a lambda input parameter?

Question

I accept that due to the lower bounded wildcard, this predicate should not accept a superclass of String without an explicit cast.[1,2] This question is rather about type safety enforcement in the lambda's parameter list. Given the second block fails compilation, why is the first allowed to compile without a warning? It appears that in the first case, despite the lambda's parameter declaration, CharSequence is being cast to String to satisfy predicate's boundary constraint.

    Predicate<? super String> predicate1 = (CharSequence c)
       -> c.toString().length() > 2 ;
    System.out.println(predicate1.test("foo"));                 // compiles

    Predicate<? super String> predicate2 = (CharSequence c)
       -> c.toString().length() > 2 ;
    System.out.println(predicate2.test((CharSequence)"foo"));  // capture error

error: method test in interface Predicate<T> cannot be applied to given types;
    out.println(predicate2.test((CharSequence)"foo")); 
                          ^
  required: CAP#1
  found: CharSequence
  reason: argument mismatch; CharSequence cannot be converted to CAP#1
  where T is a type-variable:
    T extends Object declared in interface Predicate
  where CAP#1 is a fresh type-variable:
    CAP#1 extends Object super: String from capture of ? super String

Thanks for the work on this. The issue appears to be an assumption that the lambda and the generic process would forced to consume a CharSequence. However, it's now clear that String can be submitted to the lambda without a compiler error, so what's happening in the first case and a String is being submitted to both processes. It's no surprise that the generics process is ignoring the content of the lambda.

Andy Turner · Answer 1 · 2020-06-24T19:23:00.743

4

Predicate<? super String> predicate2 = (CharSequence c)
   -> c.toString().length() > 2 ;
System.out.println(predicate2.test((CharSequence)"foo"));  // capture error

The issue is that predicate2 says it is something which will accept a String; you're trying to pass it a CharSequence.

If you change the declaration of the variable to

Predicate<? super CharSequence> predicate2

then it works.

The reason this doesn't work is that you might be passing a MyCharSequence implements CharSequence to the predicate:

System.out.println(predicate2.test((CharSequence)new MyCharSequence()));

This shouldn't be accepted, because the type of the predicate2 variable says it should only expect to be given an instance of String. The compiler only sees the type of the actual parameter as CharSequence, so it can't distinguish between "this is a String" (would be OK) and "this is a MyCharSequence" (wouldn't be OK).

edited Jun 24 '20 at 19:23

answered Jun 24 '20 at 19:21

Andy Turner

137,514
11
162
243

1

@user why wouldn't it compile? You've got a `Predicate` whose type says "I want to be able to pass a `String` to this", and you're passing a `String` to it. – Andy Turner Jun 24 '20 at 19:23
2

@user you don't know what the type is, but you know that it's some supertype of `String` (or `String` itself), so you can pass a `String` to it safely. – Andy Turner Jun 24 '20 at 19:26
Oh, I think I get it. String is-a CharSequence. A String can be submitted as a CharSequence without a cast. Unless anyone disagrees I'll withdraw this. – John Jun 24 '20 at 19:28
I'll leave it up and take it down if it gets downvotes. Thanks for a lot of good work on this. – John Jun 24 '20 at 19:43

Alanpatchi · Answer 2 · 2020-06-24T19:46:03.810

It appears that in the first case, despite the lambda's parameter declaration, String is being cast to CharSequence to satisfy predicate's boundary constraint. You said this referring to the 1st case, but there is nothing being cast to CharSequence here.

If you break your 1st case code like this,

    final Predicate<CharSequence> charSequencePredicate = (CharSequence c) -> c.toString().length() > 2;
    Predicate<? super String> predicate1 = charSequencePredicate;
    System.out.println(predicate1.test("foo"));

You will see that when the predicate1.test("foo") is called, "foo" is passed as a String, and when this String is passed to the Predicate as it's argument, the assignment to parameter c is done without any casting as String implements Charsequence.

Yes, that's correct. Even though the predicate is expecting a String, there is no reason it can't use a lambda that accepts a CharSequence. — John, Jun 24 '20 at 19:42

Why is a cast performed against a lambda input parameter?

2 Answers2