Does Java support Currying?

Question

I was wondering if there is any way to pull that in Java. I think it is not possible without native support for closures.

Answer 1

Java 8 (released March 18th 2014) does support currying. The example Java code posted in the answer by missingfaktor can be rewritten as:

import java.util.function.*; import static java.lang.System.out;  // Tested with JDK 1.8.0-ea-b75 public class CurryingAndPartialFunctionApplication {    public static void main(String[] args)    {       IntBinaryOperator simpleAdd = (a, b) -> a + b;       IntFunction<IntUnaryOperator> curriedAdd = a -> b -> a + b;        // Demonstrating simple add:       out.println(simpleAdd.applyAsInt(4, 5));        // Demonstrating curried add:       out.println(curriedAdd.apply(4).applyAsInt(5));        // Curried version lets you perform partial application:       IntUnaryOperator adder5 = curriedAdd.apply(5);       out.println(adder5.applyAsInt(4));       out.println(adder5.applyAsInt(6));    } } 

... which is quite nice. Personally, with Java 8 available I see little reason to use an alternative JVM language such as Scala or Clojure. They provide other language features, of course, but that's not enough to justify the transition cost and the weaker IDE/tooling/libraries support, IMO.

Answer 2

Currying and partial application is absolutely possible in Java, but the amount of code required will probably turn you off.

---

Some code to demonstrate currying and partial application in Java:

interface Function1<A, B> {   public B apply(final A a); }  interface Function2<A, B, C> {   public C apply(final A a, final B b); }  class Main {   public static Function2<Integer, Integer, Integer> simpleAdd =      new Function2<Integer, Integer, Integer>() {       public Integer apply(final Integer a, final Integer b) {         return a + b;       }     };      public static Function1<Integer, Function1<Integer, Integer>> curriedAdd =      new Function1<Integer, Function1<Integer, Integer>>() {       public Function1<Integer, Integer> apply(final Integer a) {         return new Function1<Integer, Integer>() {           public Integer apply(final Integer b) {             return a + b;           }         };       }     };    public static void main(String[] args) {     // Demonstrating simple `add`     System.out.println(simpleAdd.apply(4, 5));      // Demonstrating curried `add`     System.out.println(curriedAdd.apply(4).apply(5));      // Curried version lets you perform partial application      // as demonstrated below.     Function1<Integer, Integer> adder5 = curriedAdd.apply(5);     System.out.println(adder5.apply(4));     System.out.println(adder5.apply(6));   } } 

---

FWIW here is the Haskell equivalent of above Java code:

simpleAdd :: (Int, Int) -> Int simpleAdd (a, b) = a + b  curriedAdd :: Int -> Int -> Int curriedAdd a b = a + b  main = do   -- Demonstrating simpleAdd   print $ simpleAdd (5, 4)    -- Demonstrating curriedAdd   print $ curriedAdd 5 4    -- Demostrating partial application   let adder5 = curriedAdd 5 in do     print $ adder5 6     print $ adder5 9