You can't do it directly, but there is a standard idiom for doing something like that - define the interface like this:
interface Functor>
And then in the implementing class, bind R to the implementing class:
class Option implements Functor>
However, this doesn't let you write an actual functor. Try to write the map method on it:
class Option implements Functor> {
private final A value;
public Option(A value) { this.value = value; }
@Override
public Option map(Function fn) {
// er, i want to return an Option, not an Option
}
}
The problem is that you don't want to return an instance of the type of the receiver, you want to return an instance of a similar type with a different type parameter (Option
rather than Option).You would be absolutely fine if your functions were functions from values of some type to other values of that type (eg functions from integers to integers), because then A = B and you can get away with this. But there's no way to extend this hack to let you return an Option from map.
The closest you can get in Java is probably this:
interface Functor>
class Option implements Functor> {
private final A value;
public Option(A value) { this.value = value; }
@Override
public Option map(Function fn) {
return new Option(value != null ? fn.apply(value) : null);
}
}
There, you leave the element type of the returned functor undefined, as a wildcard, which lets you slip an Option
out as a return value.The problem with that is that it's useless. Given:
Option x;
Function fn;
Then mapping the function over the option gives you:
Option y = x.map(fn);
An Option. Which is no use to man or beast, because it's lost the type information.
What you really want to be able to write is:
class Option implements Functor>
Where the underscore is borrowed from Scala to mean "nothing to see here, move along please", and leaves that reference to Option in its unbound form. And then have a way of binding it right in the definition of the map function. But that's higher-kinded types, and Java doesn't have that.
If you were absolutely desperate to do this in Java, like if terrorists burst in and put a gun to your head and told you to do it, you could restore the type information by pebble-dashing the functor with some simple reflection:
interface Functor> {
R map(Function fn);
Functor as(Class b);
}
class Option implements Functor> {
// other stuff as above
@Override
public Option as(Class b) {
return new Option(b.cast(value));
}
}
Which, given the above definitions of x and fn, lets you write:
Option y = x.map(fn).as(Integer.class);
And even the same thing but typed as functors, to show you there's nothing up my sleeve:
Functor> fx = x;
Functor> fy = fx.map(fn).as(Integer.class);
And as a separate function which contains no mention of the concrete functor class anywhere (although it does still need a type token for the result functor's parameter):
private > Functor applyAbstractly(Functor fx, Function fn, Class b) {
return fx.map(fn).as(b);
}
But to be honest, all of this is a bit like trying to carve a fine wooden sculpture with a chainsaw. If you want to do this, don't use Java. If you want to use Java, don't do this.