Java 8: Where is TriFunction (and kin) in java.util.function? Or what is the alternative?

D

14

176

I see java.util.function.BiFunction, so I can do this:

BiFunction<Integer, Integer, Integer> f = (x, y) -> { return 0; };

What if that is not good enough and I need TriFunction? It doesn't exist!

TriFunction<Integer, Integer, Integer, Integer> f = (x, y, z) -> { return 0; };

I guess I should add that I know I can define my own TriFunction, I'm just trying to understand the rationale behind not including it in the standard library.

Disgruntle answered 23/8, 2013 at 10:11 Comment(5)

with bifunction interface, you can easly define N-function class, if you define trifunction as separate interface, first sb will be asking why not quadofunction, and second, you need to duplicate all methods which takes Bifunction as parameter – Chute 23/8, 2013 at 10:48

There is a point of diminishing returns for APIs like this. (Personally, I think JDK8 passed it a while back, but this is beyond even that.) – Skirr 23/8, 2013 at 16:27

I believe the rationale was to say that Function and BiFunction were fully implemented with objects and native types. Including TriFunctions with all the various variations would blow up the JRE with classes and methods. – Aboveboard 25/6, 2019 at 10:17

Short answer. In Java, if you don't see it, you build your own (see Alex P answers of course). Sidenote, in C#, the implementers of dotnet gave you pre-canned ones (up to 16 arguments), but without the prefix names ("Bi" here) : see learn.microsoft.com/en-us/dotnet/api/… Just a simple "Func". So this is one of the places I prefer dotnet over java. Please don't turn this comment section into a h0ly war. and limit comments to BiFunction only. – Folsom 6/9, 2019 at 14:24

Just like any thing else. If the API doesn't provide it, then code it yourself. – Supersensitive 15/2, 2021 at 17:52

O

94

As far as I know, there are only two kinds of functions, destructive and constructive.

While constructive function, as the name implies, constructs something, a destructive one destroys something, but not in the way you may think now.

For example, the function

Function<Integer,Integer> f = (x,y) -> x + y

is a constructive one. As you need to construct something. In the example you constructed the tuple (x,y). Constructive functions have the problem, of being not able to handle infinite arguments. But the worst thing is, you can't just leave an argument open. You can't just say "well, let x := 1" and try out every y you may like to try. You have to construct every time the whole tuple with x := 1. So if you like to see what the functions return for y := 1, y := 2, y := 3 you have to write f(1,1) , f(1,2) , f(1,3).

In Java 8, constructive functions should be handled (most of the time) by using method references because there's not much advantage of using a constructive lambda function. They are a bit like static methods. You can use them, but they have no real state.

The other type is the destructive one, it takes something and dismantles it as far as needed. For example, the destructive function

Function<Integer, Function<Integer, Integer>> g = x -> (y -> x + y)

does the same as the function f which was constructive. The benefits of a destructive function are, you can handle now infinite arguments, which is especially convenient for streams, and you can just leave arguments open. So if you again want to see what would the result be like if x := 1 and y := 1 , y := 2 , y := 3 , you can say h = g(1) and h(1) is the result for y := 1, h(2) for y := 2 and h(3) for y := 3.

So here you have a fixed state! That's quite dynamic and that's most of the time that what we want from a lambda.

Patterns like Factory are a lot easier if you can just put in a function which does the work for you.

Destructive ones are easily combined with each other. If the type is right you can just compose them as you like. Using that, you can easily define morphisms which make (with immutable values) testing a lot easier!

You can do that too with a constructive one, but destructive composition looks nicer and more like a list or a decorator, and the constructive one looks a lot like a tree. And things like backtracking with constructive functions are just not nice. You can just save the partial functions of a destructive one (dynamic programming), and on "backtrack" just use the old destructive function. That makes code a lot smaller and better readable. With constructive functions you have more or less to remember all arguments, which can be a lot.

So why is there a need for BiFunction should be more of question than why there is no TriFunction?

First of all, a lot of time you just have a few values (less than 3) and need just a result, so a normal destructive function would not be needed at all, a constructive one would do fine. And there are things like monads which really needs a constructive function. But aside from that, there are not really a lot of good reasons why there is a BiFunction at all. Which doesn't mean it should be removed! I fight for my Monads until I die!

So if you have a lot of arguments, which you can't combine into a logical container class, and if you need the function to be constructive, use a method reference. Otherwise try to use the new gained ability of destructive functions, you may find yourself doing a lot of things with a lot less code lines.

Older answered 15/2, 2014 at 13:7 Comment(15)

You answered my question...I think...I don't know if the java language designers are coming from this line of thinking, but I'm not well-versed in functional programming. Thank you for the explanation. – Disgruntle 21/2, 2014 at 1:39

I updated my answer too. The problem with the currying approach is that Java was never meant to do that. Unless you switch to Scala, using g becomes a hassle: g.apply(1).apply(2); etc. – Sollars 3/11, 2014 at 22:48

I've never seen the terms constructive and destructive being used to refer to the concepts you describe. I think curried and non-curried are more common terms. – Veron 3/6, 2015 at 12:38

The first function example is not syntactically correct. It should be BiFunction and not Function, because it takes two input arguments. – Fugitive 29/4, 2016 at 22:10

IMO BiFunction was created to allow easy data reduction, and most Streams terminal operations are just data reductions. A good example is BinaryOperator<T>, used in many Collectors. A first element is reduced with the second one, than can then be reduced with the next one, and so on. Of course, you could create a Function<T, Function<T, T> func = x -> (y -> /*reduction code here*/). But, seriously? All of this when you can simply do BinaryOperator<T> func = (x, y) -> /*reduction code here*/. Plus, this data reduction approach seems a lot like your "destructive" approach to me. – Arbitrage 23/3, 2017 at 12:20

I had no idea about this way of create functions!, awesome man!!!. You make my day! – Lycanthropy 24/6, 2017 at 9:48

How did this get so many upvotes? It's a terrible and confusing answer, because it's based on the premise that Function<Integer,Integer> f = (x,y) -> x + y is valid Java, which it isn't. That should be a BiFunction to begin with! – Gaudette 29/3, 2018 at 10:26

There is a common use case for BiFunction or BiConsumer: whevever you wand to pass a method as argument, as in

public class Foo { public void bar(String arg) {...} public void doSomething(BiConsumer<Foo, String> method, String arg) { method.accept(this, arg); } public void callBar(String arg) { doSomething(Foo::bar, arg); } }

- and hence the need for TriConsumer etc... – Aubert 22/5, 2019 at 10:46

SmallTalk lang libs have these functions up to 16 args for a while, afaik. The way of thinking described in this answer should be considered harmfull. The only way for this to live is in pure academic vacuum. In case of java, nesting function definition is inproductive and will cause cascaded design problems and excessive object creation. Do not follow this advice IRL – Vickivickie 1/8, 2019 at 14:50

The first example should be BiFunction<Integer,Integer,Integer> I think it's unnecessarily complicated that Java uses those statically typed function definitions. There's no reason to have multiple function/consumer definitions, the arguments should be variable – Witkowski 30/10, 2019 at 18:14

The language that caters for this kind of thinking would be functional languages like Haskell. They do a lot of function sum (a, ...more_a): return a + sum(more_a) (non-working pseudocode) shenanigans. – Sebrinasebum 17/7, 2020 at 5:13

What is "infinite arguments" supposed to mean here and in what way would it be convenient when using streams? – Emmert 30/9, 2020 at 17:19

There’s also callbacks, and I like mine with arbitrary many parameters. – Saxophone 12/1, 2021 at 18:51

I keep coming to this question once in a year or so, every time wondering "Where does Java have the TriFunction again?". Every time, I bump into this answer. It makes no sense whatsoever. It's so annoying. ಠ_ಠ – Little 20/5, 2021 at 1:24

Quite a big assumption here. I can think of use case of TriFunction in financial domain. E.g: to calculate a butterfly price product where you'll need to calculate all 3 elements with different factor between first element, second one and third one and apply different mathematical function to those 3 elements. – Rare 16/3, 2022 at 9:27

S

218

If you need TriFunction, just do this:

@FunctionalInterface
interface TriFunction<A,B,C,R> {

    R apply(A a, B b, C c);

    default <V> TriFunction<A, B, C, V> andThen(
                                Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (A a, B b, C c) -> after.apply(apply(a, b, c));
    }
}

Following small program shows how it can be used. Remember that result type is specified as a last generic type parameter.

  public class Main {

    public static void main(String[] args) {
        BiFunction<Integer, Long, String> bi = (x,y) -> ""+x+","+y;
        TriFunction<Boolean, Integer, Long, String> tri = (x,y,z) -> ""+x+","+y+","+z;


        System.out.println(bi.apply(1, 2L)); //1,2
        System.out.println(tri.apply(false, 1, 2L)); //false,1,2

        tri = tri.andThen(s -> "["+s+"]");
        System.out.println(tri.apply(true,2,3L)); //[true,2,3]
    }
  }

I guess if there was practical use for TriFunction in java.util.* or java.lang.* it would have been defined. I would never go beyond 22 arguments, though ;-) What I mean by that, all new code that allows to stream collections never required TriFunction as any of the method parameters. So it was not included.

UPDATE

For completeness and following the destructive functions explanation in another answer (related to currying), here is how TriFunction can be emulated without additional interface:

Function<Integer, Function<Integer, UnaryOperator<Integer>>> tri1 = a -> b -> c -> a + b + c;
System.out.println(tri1.apply(1).apply(2).apply(3)); //prints 6

Of course, it is possible to combine functions in other ways, e.g.:

BiFunction<Integer, Integer, UnaryOperator<Integer>> tri2 = (a, b) -> c -> a + b + c;
System.out.println(tri2.apply(1, 2).apply(3)); //prints 6
//partial function can be, of course, extracted this way
UnaryOperator partial = tri2.apply(1,2); //this is partial, eq to c -> 1 + 2 + c;
System.out.println(partial.apply(4)); //prints 7
System.out.println(partial.apply(5)); //prints 8

While currying would be natural to any language that supports functional programming beyond lambdas, Java is not built this way and, while achievable, the code is hard to maintain, and sometimes read. However, it is very helpful as an exercise, and sometimes partial functions have a rightful place in your code.

Sollars answered 29/10, 2013 at 4:7 Comment(5)

Thanks for the solution. And yes, there is definitely use for BiFunction, TriFunction, ... Otherwise people would not search for it. It guess the whole lambda thing is just too new for Oracle right now and will be extended in later Java versions. At the moment it's more a proof of concept. – Astrakhan 25/2, 2014 at 9:1

Hy @Alex can you please define following line. whats happening here default <V> TriFunction<A, B, C, V> andThen( Function<? super R, ? extends V> after) { Objects.requireNonNull(after); return (A a, B b, C c) -> after.apply(apply(a, b, c)); } – Isherwood 11/9, 2015 at 9:42

@MuneebNasir - it allows you to do function composition:

TriFunction<Integer,Integer,Integer,Integer> comp = (x,y,z) -> x + y + z; comp = comp.andThen(s -> s * 2); int result = comp.apply(1, 2, 3); //12

See #19835111 – Sollars 11/9, 2015 at 16:23

Added andThen() usage example to the answer. – Sollars 11/9, 2015 at 16:34

Not only currying is not well adapted to Java language, but also, correct me if I'm wrong, but BiFunction is used in the Stream API to perform data reduction, which looks a lot like the currying approach to me: you never take more than two arguments, and you can process any number of elements, one reduction at a time (see my comment on the accepted answer, I'd be happy to know if I'm wrong to see it that way). – Arbitrage 23/3, 2017 at 12:23

O

94

As far as I know, there are only two kinds of functions, destructive and constructive.

While constructive function, as the name implies, constructs something, a destructive one destroys something, but not in the way you may think now.

For example, the function

Function<Integer,Integer> f = (x,y) -> x + y

is a constructive one. As you need to construct something. In the example you constructed the tuple (x,y). Constructive functions have the problem, of being not able to handle infinite arguments. But the worst thing is, you can't just leave an argument open. You can't just say "well, let x := 1" and try out every y you may like to try. You have to construct every time the whole tuple with x := 1. So if you like to see what the functions return for y := 1, y := 2, y := 3 you have to write f(1,1) , f(1,2) , f(1,3).

In Java 8, constructive functions should be handled (most of the time) by using method references because there's not much advantage of using a constructive lambda function. They are a bit like static methods. You can use them, but they have no real state.

The other type is the destructive one, it takes something and dismantles it as far as needed. For example, the destructive function

Function<Integer, Function<Integer, Integer>> g = x -> (y -> x + y)