Java F-Bound types with generics

Question

Is there any way to express f-bound types in java where at the call site, a generic response is returned?

interface Functor<T extends Functor<T>>
  public <B> T<B> map(Function<A, B> fn); // won't compile because types don't match

I can use f-bound types if the type never changes, but in the case of map, I need a new type. Is there a way to express this in java?

What I am really looking for is any way that I can get something like higher kinds even though I know javac doesn't support higher kinded types.

Lets say we have a List<A> and want this interface to return a List<B>. But don't want this interface to know anything about List.

That wont let me return a `T` in the map. My current type would be a T, and I need to return a T. — ekaqu, Aug 22 '14 at 06:13
So where did `A` come from? It's not formally defined anywhere. — Makoto, Aug 22 '14 at 06:34
Thats what I am trying to figure out. Maybe I am looking at this in terms of higher order types, Updated my comment to reflect this better. — ekaqu, Aug 22 '14 at 21:01
Can you add an example of the usage you're thinking of? With what would you call Functor.map, what would you expect returned? — Andreas, Aug 22 '14 at 21:13
See this answer on how to encode higher order types in Java: https://stackoverflow.com/questions/7451658/can-i-use-nested-generics-aka-higher-kinded-types-in-java/70721895#answer-70721895 — michid, Jan 21 '22 at 12:22

score 0 · Accepted Answer · answered Aug 25 '14 at 18:56

Reading the Wikipedia definition of functor, it sounds like you want to define a generic type which is able to map from one category (Java type) to another. In your example above, to map from a List<A> to List<B> where the types A and B are generic.

If this is your aim, then consider the following interface for the definition of a Functor type:

public interface Functor<CategoryA, CategoryB> {
    public CategoryB map(CategoryA instance);
}

This declares that the Functor type deals in two generic parameter types, CategoryA and CategoryB and no constraints are put on these parameter types. It also declares that a method map must be implemented which maps from an object of type CategoryA to an object of type CategoryB.

Suppose, based on your example, you now want to create a concrete instance of a Functor which maps from List<Integer> to List<String>. You might create the following class:

public class IntegerListToStringList implements Functor<List<Integer>, List<String>> {
    @Override
    public List<String> map(List<Integer> integerList) {
        List<String> stringList = new ArrayList<>(integerList.size());
        for(Integer intValue : integerList) {
            stringList.add(Integer.toString(intValue));
        }
        return stringList;
    }
}

You could then invoke this concrete Functor implementation like so:

Functor<List<Integer>, List<String>> functor = new IntegerListToStringList();
Integer[] intArray = new Integer[] {2, 3, 5, 7, 11, 13};
List<Integer> intList = Arrays.asList(intArray);
List<String> stringList = functor.map(intList);
System.out.println("String list: " + stringList);

Now any method which is expecting a parameter of type Functor<List<Integer>, List<String>> can accept an instance of type IntegerListToStringList.

That should work find if I make the `ListFunctor` class paramitorized. The higher kinded part is to scope it down so the input and the output have the same outer type (list in this example), but could lower this requirement by making all basic impls provide it... — ekaqu, Sep 23 '14 at 18:34

Java F-Bound types with generics

1 Answers1

Linked