New Collections interface - Sized

[Brian Goetz]

>> Is there a compelling example of where this would be used by clients?
> Here are some examples:
> https://stackoverflow.com/questions/10988634/java-global-isempty-method
Without passing judgment on the sort of dynamically typed programs that 
need a method like this, or wondering what monstrosities such code uses 
to actually _get_ the data out of this weird ad-hoc union, note that 
this code becomes dramatically simpler with pattern matching:

     return switch (c) {
         case null -> true;
         case CharSequence cs -> cs.length() == 0;
         case Collection c -> c.isEmpty();
         case Object[] os -> os.length == 0;
         default -> { weird reflective thingy }
     }

Note also that a Sized abstraction only addresses two of these five 
cases -- CharSequence and Collection.  The others would still require 
such ad-hoc treatment.

And while it may seem like I have pattern matching on the brain, there's 
a point to bringing up pattern matching -- which is that real code often 
ends up dealing with ad-hoc unions, and a linguistic mechanism for 
abstracting computations over ad-hoc unions is often a better solution 
if you find yourself in ad-hoc land than trying to partially unify it.

But again, if you are treating these things as containers, then a Sized 
doesn't get you very far, because if you conclude the thing isn't empty, 
you're going to want to get stuff out, and Sized has no methods for 
that.  So presumably there's some companion to Sized for accessing 
elements by index:

     interface HasStuff<T> extends Sized {
         T get(int index);
     }

And note that in order for HasStuff to be useful, it has to extend 
Sized, because, no intersection types.  Which suggests Sized is not the 
abstraction you are looking for.

And again, pattern matching:

     Object getElement(Object thingWithStuff, int index) {
         return switch (thingWithStuff) {
             case null -> null;
             case Object[] os -> os[index];
             case Collection<?> c -> c.get(index);
             ... more if you can think of them ...
        };