What can this be used for?
As a language implementer on the Java platform, I think interface injection would be a blessing. In fact, I think it is the one thing that would simplify the implementation of languages on the JVM the most. Any language probably has a base interface (as Java has
java.lang.Object and Jython has
org.python.core.PyObject), let's be unbiased and call it "
MyLangObject" for the sake of the continued discussion. There are two things that make the Java platform great:
- There are a lot of really good toolkits and libraries implemented for the Java platform.
- There are a lot of great languages for the Java platform in which even more great libraries and toolkits will be developed.
Therefore, if you are implementing a language for the Java platform you would want to interact with all of these libraries and toolkits. Problem is that most of them haven't been designed with your language in mind, and they shouldn't be. If
MyLangObject was an injectable interface all you would need to do to be able to integrate with any object from another language would be to just interact with it through the
MyLangObject interface, and the injection mechanism would take care of the rest.
The injection mechanism could even be used with the classes within your language. Instead of having a base class supplying the default implementation of the methods of
MyLangObject you could let the injection method return the default implementation for your methods.
Or why not use interface injection to support function invocation with different argument counts. Each function in your language would implement a set of
call methods, one for each argument count it can be invoked with. Your language would then have a set of injectable
Callable interfaces one for each argument count that any function in your language can be invoked with, each with only one
call method, with the appropriate number of arguments. These interfaces could be generated at runtime if your language supports runtime code generation. The default implementation of the call method in each
Callable interface would of course raise an exception, since the function obviously doesn't support that argument count if it doesn't implement the appropriate method.
Interface injection really does provide a huge set of opportunities.