Closures - use case - instanceof

Another 'use case' for the closures proposal following on from yesterday. This time a problematical one - instanceof.

ifInstanceOf

  Object obj = ...;
  ifInstanceOf (String str : obj) {
    // do something with the string
  }

The intention of this closure method is to take the input object 'obj', check if it matches the required type, and then call the closure itself with the typecast object 'str'. Thus, this operation is the closure equivalent of this current operation:

  Object obj = ...;
  if (obj instanceof String) {
    String str = (String) obj;
    // do something with the string
  }

So, how would the implementation of the method look? Well the implementation needs to be generic, as we can't just handle String objects. So, lets use T to represent the type that we are testing:

public static [T] void ifInstanceOf(Object obj, {T=>void} block) {
  if (obj instanceof T) {
    block.invoke((T) obj);
  }
}

Unfortunately, this won't compile, as you can't write obj instanceof T where T is a generic type. The problem is of course erasure. This method has no way of determining what the actual type of T is - String in this example. So what can be done?

One solution would be to pass the type in as an additional parameter from the calling code:

  Object obj = ...;
  ifInstanceOf (String str : obj, String.class) {
    // do something with the string
  }

But that is just rubbish, as you could define a different type as the Class object and get a ClassCastException - ifInstanceOf (String str : obj, Integer.class)!.

A better solution would be for closure blocks to store the actual invoked generic types as instance variables. Then we could write:

public static [T] void ifInstanceOf(Object obj, {T=>void} block) {
  if (block.actualType(0).isInstance(obj)) {
    block.invoke((T) obj);
  }
}

This would be fairly simple to do, and in fact could probably be optimised by the compiler so that the actual types are only stored if the actualType method is called.

I'm not sure if this is the only use-case where the actual types of the closure would be useful, but I suspect it isn't. If you've got another use-case where the actual type would be useful, or any other feedback, please add a comment!