Type Witnesses -- just know they exist and their syntax and then forget about them?

[Jesse Silverman]

For the life of me I can't figure out why I can't find the thread where I once asked about Type Witnesses and was instructed that they used to be marginally useful, but for reasons I don't remember have become just a Trivia Answer in Java 8 and beyond and we can pretty much forget about them as long as we don't freak out when we see them on exams or in older code.

They are mentioned in the 816/819 Sybex book, in that context...one answer choice to a mock question is:

Helper.<NullPointerException>printException( new NullPointerException ("D") );

Option D uses an odd syntax by explicitly listing the type, but you should be able to recognize it as acceptable.

Is that what I should be remembering?
"When you stick a <Classname> between the . after the name of a class (for calling a static method) or the reference and the name of the method you are calling from it, that's this old thing called a Type Witness.  It used to be marginally useful, but for reasons you don't need to know if you don't care for trivia, you basically don't need them anymore in Java 8.  Don't freak out if you see them in older code or on an exam"?

[Campbell Ritchie]

No idea where your old post went.

[Jesse Silverman]

The default scope of the Search was more restricted in terms of Forum than I had realized when I hit Search.

My new default is to look and pay attention to which forums I am searching before I hit <Search>

[Stephan van Hulst]

If your goal is to get through life without getting lost in all the ugly details, then yes, you can mostly forget about type witnesses in Java. They are only very rarely useful, and even when they are, you can usually get rid of them by introducing intermediate variables to help Java's automatic type inference:

// Doesn't compile because Java can't infer that naturalOrder() should return a Comparator<String>:
names.stream().sorted(naturalOrder().reversed()).forEach(printer::println);

// Use a type witness to specify the type of the comparator:
names.stream(Comparator.<String>naturalOrder().reversed()).forEach(printer::println);

// Alternatively, introduce an intermediate variable:
Comparator<String> naturalOrder = naturalOrder();
names.stream().sorted(naturalOrder.reversed()).forEach(printer::println);

(Yes, I'm aware that Comparator also has the static reverseOrder() method that can be used instead of naturalOrder().reversed(), but for sake of argument let's pretend it doesn't exist.)

It's still nice to know about type witnesses in general though. Languages that have better runtime support for generics (such as C#) make hefty use of type witnesses (although I'm not sure they're called that way in those languages). Here's an example:

var names = maybeNullNames ?? Enumerable.Empty<string>();

[Jesse Silverman]

Thank you Stephan!

I tend to go for intermediate variables to make code clearer.
Not just to read, but to debug.

I have spent years of my life (well-paid, but otherwise lost) debugging

result = fun1( fun2( x + y, z) / fun3( w % average( c[0]  - fun4() ) ) );

when that code someone else wrote yielded a crash/stack trace "at line 791".

Not an edifying use of time.