Concise way of composing Java method references?

Question

Given some Java 8 method functions:

class Foo { Bar getBar() {} }
class Bar { Baz getBaz() {} }

A composition of the two accessors looks like:

Function<Foo, Bar> getBarFromFoo = Foo::getBar;
Function<Bar, Baz> getBazFromBar = Bar::getBaz;
Function<Foo, Baz> getBazFromFoo = getBarFromFoo.andThen(getBazFromBar);

Is there a more concise way? This seems to work

((Function<Foo, Bar>) Foo::getBar).andThen(Bar::getBaz)

But it's rather ugly. The outer parens make sense for precedence reasons, but why is the cast necessary?

(Foo::getBar::getBaz would be nice, but alas...)

Answer 1

Let's define a functional interface:

@FunctionalInterface
interface MyFunctionalInterface {
    Bar getBar(Foo f);
}

We can simplify the method reference Foo::getBar a bit,

(Foo foo) -> foo.getBar();

which means "take a Foo and return a Bar". For that description, a lot of methods are suitable (for instance, our interface with the getBar and a Funtion<Foo, Bar> with its apply):

MyFunctionalInterface f1 = (Foo foo) -> foo.getBar();
Function<Foo, Bar> f2 = (Foo foo) -> foo.getBar();

That is the answer to the question why the cast is necessary.

---

To answer the question whether there is a more concise way affirmatively, we have to set a context. The context unambiguously gives us a Function to continue working with:

class Functions {
    public static <I, O> Function<I, O> of(Function<I, O> function) {
        return function;
    }
}

Functions.of(Foo::getBar).andThen(Bar::getBaz);