Generics Problem

Question

I have a coding requirement that I would like to solve using generics, though I can't seem to get past an issue. My real example is way too complicated to post all of it here, but I'll try to simplify as much as possible (meaning, let's not get caught up in all the error checking, etc).
I have an interface:
public interface Function<T> {
     public void doSomething(T value);
}Then, I have a class:
public class LengthFunction implements Function<String> {
     private int length;
     public void doSomething(String value) {
          this.length += value.length();
     public int getLength() { return this.length; }
}And, another class:
public class CountFunction<T> implements Function<T> {
    private int count;
    public void doSomething(T value) {
        count++;
    public int getCount() { return this.count; }
}Then, I have the workhorse:
public class WorkHorse<C, T> {
    private HashMap<String, Function<T>> map;
    private Collection<C> list;
    public WorkHorse(Collection<C> incoming) {
        this.map = new HashMap<String, Function<T>>();
        this.list = new ArrayList<C>(incoming);
   public void addFunction(String key, Function<T> function) {
       this.map.put(key, function);
   public void process() {
        for (C element : this.list) {
             for (String key : this.map.keySet()) {
               for (Function<T> function : this.map.get(key)) {
                       T value = (T)magicalThingToGetValueFromElementOfTypeT(element, key);  // returns object
                    function.doSomething(value);
}And finally, a process somewhere (let's play it this way):
public void Process {
    public static void main(String[] args) {
         ArrayList<String> strings = new ArrayList<String>();
         // Fill array list with strings
         WorkHorse<String, Object> wh = new WorkHorse<String, Object>(strings);
         LengthFunction lf = new LengthFunction();
         CountFunction<Double> cf = new CountFunction<Double>();
         wh.addFunction("length", lf); // Compiler Error Here
         wh.addFunction("count", cf); // Compiler Error Here
         wh.process();
         System.out.println("Length: " + lf.getLength());
         System.out.println("Count: " + cf.getCount());       
}The two places where it complains are noted, and it is complaining with:
The method addFunction(String, Function<Object>) in the type WorkHorse<String,Object> is not applicable for the arguments (String, LengthFunction<String>)and
The method addFunction(String, Function<Object>) in the type WorkHorse<String,Object> is not applicable for the arguments (String, CountFunction<Double>)So, I'm missing something... and I appear to be too stupid to figure it out.
Any help is appreciated.
Joe

Answer 1

I haven't seen the "? super C" syntax. How is that different from "? extends C"?
Since the function argument type will be the same as the collection contents type, there's no reason for having two type parameters on WorkhorseThere is. The first parameter on WorkHorse is the type of the elements in the collection. The second is the type of a value a given function is designed to work against. That value is obtained by invoking a method on each element in the list and then provided to the function. That is pretty complicatated, and relatively unimportant for this problem, so I elided with:
T value = (T)magicalThingToGetValueFromElementOfTypeT(element, key);  // returns objectSo, therefore, if given an element of type MathThing in the WorkHorse, and that type has a method that returns a Double, then we'd want WorkHorse<MathThing, Double>. Likewise, if we have an element of type ColorThing, and it has a method that returns a Color, we'd want WorkHorse<ColorThing, Color>. Then, we'd have something like AFunction<Double> and BFunction<Color>.
I was interested, though, and made a quick change to the WorkHorse class... and I'm still getting fundamentally the same error:
The method addFunction(String, Function<? super Object>) in the type WorkHorse<String,Object> is not applicable for the arguments (String, Function<String>)When I instantiate WorkHorse with <String, Object>. Again, if I do WorkHorse<String, String> and use only implementations equivalent to Function<String>, I'm OK. However, if I do WorkHorse<String, Object> and have two Function<Strings> and one Function<Double>, I have the problem.