Generics for Higher Order Function Support

Question

Perhaps I'm not looking hard enough, but it seems that all arguments for generics relate to containers. Has anyone considered the impact of generics and at least rudimentary type inference on higher order function support.
Consider the case in which you want to execute a particular operation under time constraints, or with specified cleanup operations to occur afterwards, for example:
interface DBOperation
  void doOperation(Connection con);
void DoDBOperation(DBOperation op)
  Connection c = acquireConnection()
  try
    op.doOperation(con);
  finally
    c.release();
}One would then call:
DoDBOperation(new DBOperation() ...);Now what happens if I want to make a DBOperation that returns an integer and throws a specific checked exception. I would need to define an alternative DBOperation2 class, and rewrite DoDBOperation for each possible permutation of checked exceptions, and for each return type.
Or one would just have:
interface DBOperation
  Object doOperation(Connection inCon) throws Exception
}But now when I call it, I need to catch Exception, not just the ones I specifically throw, and I have to cast the return type.
Clearly, a generics mechanism with type inference could infer the appropriate throws and return type for the DoDBOperation call, given the compile-time type of the parameter.

Answer 1

Ahh, i think I'm starting to see. My guess is that to achieve that in the current generic Java proposal, it would need to look something like:
public interface OperationInterface<T extends Object, X extends Exception>
   <T> doOperation() throws <X>
public class LoggedOperation<T extends Object, X extends Exception> implements OperationInterface<T, X>
  OperationInterface<T, X> delegatee;
  public LoggedOperation<T extends Object, X extends Exception>(OperationInterface<T, X> d)
    delegatee = d;
  <T> doOperation() throws <X>
    logStart();
    try {
      return delegatee.doOperation();
    finally {
      logEnd();
Or somesuch.  The important thing to note is that the genericity is on the objects, not on their methods. So it can behave a little like you suggest, provided the class is created properly in the first place.
Note: I haven't tried the demo version of the generic compiler, so I'm sure every line of that code is wrong.