Friday, June 11, 2010


Steve suggested: For this to work like you want, Java style, you'd have to add a Class member to the Box class, to represent the type of Box at runtime.

Like this:
public final class Box<E> {

  private final Class<E> type;
  private final E value;

  public Box (Class<E> type, E value) {
    this.type = checkNotNull(type, "type");
    this.value = value;

  public E getValue() {
    return value;

  public boolean isType (Class<?> specific) {
    return specific == this.type;

  public <X> Box<X> asType (Class<X> specific) {
    if (isType(specific)) {
      return (Box) this;
    } else {
      throw new ClassCastException();
You could then write a static generic filter taking an Iterable of generic Boxes and a Class object to filter by, and returning an Iterable of the correct type fairly simply.

Sort of like this (assuming appropriate definitions of map and filter):
// The essential code is in a bold green face.

public <X> Iterable<Box<X>> boxesOfType (final Class<X> type,
                                         Iterable<Box<?>> boxes) {
      map (
          filter (
              new Predicate<Box<?>> () {
                public boolean apply (Box<?> box) {
                  return box.isType(type);
          new Function<Box<?>, Box<X>> () {
            public Box<X> apply (Box<?> box) {
              return box.asType(type);
Dunno if that floats your boat, tho.

It definitely floats my boat (thanks, Steve) in that I can now, in a typesafe manner, take a bunch of heterogeneous boxes and select and downcast them to a subset of homogeneous boxes.

I'll discuss the leaks in the boat in the next post.


mquander offered a C# solution to the same problem:
internal interface IBox { }
public class Box<T> : IBox
    public T Value;
public static class BoxManipulators
    public static int MinimumIntegerInBox(IEnumerable<IBox> boxes)
        return boxes.OfType<Box<int>>().Min(x => x.Value);