# Function Composition

John Nilsson john at milsson.nu
Tue Jan 1 16:29:53 PST 2013

```Btw, compose and andThen feels like Scala to me. So there's some precedence
for that choice of names. Did you have any other source in mind? Besides
the proliferation of the ∘ in math texts I can't really think of any
specific common understanding of "compose" meaning some specific thing, I
don't think Scala qualifies as "common" at this time.
So my argument was that even the math people can agree to interpret
"compose" as ";", while less commonly used, it's the same operation.
Given that we both agree that "andThen" should be used instead, why even
have the other? And if there is only the one, why not call it by it's
natural name "compose"?

BR,
John

On Wed, Jan 2, 2013 at 1:17 AM, Jed Wesley-Smith <jed at wesleysmith.io> wrote:

> Well, I'm not arguing the merits of one or the other, indeed I'd like
> both (and I usually use the andThen/; form). I'd just argue that this
> is a well established name/form and there is value (as in least
> surprise) in following the precedent.
>
> Function<A, B> f = …
> Function<B, C> g = …
>
> Function<A, C> c = g.compose(f);
> Function<A, C> d = f.andThen(g);
>
> I'd argue the second form reads better anyway!
>
> cheers,
> jed.
>
> On 2 January 2013 11:07, John Nilsson <john at milsson.nu> wrote:
> > For what it's worth. I think the math people got it wrong with "∘". The
> > other operation they call compose: ";" - which has applicative order -
> feels
> > more natural. So one vote for keeping compose as ";". Also, this is the
> > composition operation for statements Java programmers have been using for
> > years with no complaint, so why arbitrarily switch to "∘" for function
> > composition?
> > Besides even the math people revert to applicative order when modelling
> > function composition as a category.
> >
> > BR,
> > John
> >
> >
> > On Wed, Jan 2, 2013 at 12:40 AM, Jed Wesley-Smith <jed at wesleysmith.io>
> > wrote:
> >>
> >> hello lambdarians!
> >>
> >> Just noticed that the java.util.function.Function.compose method is
> >> round the wrong way (according to the common definition of function
> >> composition*).
> >>
> >> The current lambda definition:
> >>
> >>
> >>
> http://hg.openjdk.java.net/lambda/lambda/jdk/file/858e2f478d62/src/share/classes/java/util/function/Function.java
> >>
> >> has f.compose(g) mean apply f and then apply g, whereas the usual
> >> (most other languages and the literature) has f ∘ g mean apply g and
> >> then apply f.
> >>
> >> The form that Function has currently is commonly known as andThen. So,
> >> you could rename the current method andThen and add a new compose
> >> method that works in the usual manner.
> >>
> >> cheers,
> >> jed.
> >>
> >> * references:
> >> http://en.wikipedia.org/wiki/Function_composition
> >> http://en.wikipedia.org/wiki/Function_composition_(computer_science)
>
```