¿Java es compatible con Currying?

Me preguntaba si hay alguna forma de lograr eso en Java. Creo que no es posible sin soporte nativo para cierres.

Java 8 (lanzado el 18 de marzo de 2014) admite currying. El código Java de ejemplo publicado en la respuesta de missingfaktor puede reescribirse como:

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 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)); } } 

… que es bastante agradable. Personalmente, con Java 8 disponible, veo pocas razones para usar un lenguaje JVM alternativo como Scala o Clojure. Ofrecen otras características del lenguaje, por supuesto, pero eso no es suficiente para justificar el costo de transición y el soporte más débil de IDE / herramientas / bibliotecas, IMO.

Currying y la aplicación parcial es absolutamente posible en Java, pero la cantidad de código requerido probablemente lo desconecte.


Algunos códigos para demostrar el currying y la aplicación parcial en Java:

 interface Function1 { public B apply(final A a); } interface Function2 { public C apply(final A a, final B b); } class Main { public static Function2 simpleAdd = new Function2() { public Integer apply(final Integer a, final Integer b) { return a + b; } }; public static Function1> curriedAdd = new Function1>() { public Function1 apply(final Integer a) { return new Function1() { 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 adder5 = curriedAdd.apply(5); System.out.println(adder5.apply(4)); System.out.println(adder5.apply(6)); } } 

FWIW aquí es el equivalente Haskell del código Java anterior:

 simpleAdd :: (Int, Int) -> Int simpleAdd (a, b) = a + b curriedAdd :: Int -> Int -> Int curriedAdd ab = 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 

EDITAR : A partir de 2014 y Java 8, la progtwigción funcional en Java ahora no solo es posible, sino que tampoco es fea (me atrevo a decir que es hermosa). Ver por ejemplo la respuesta de Rogerio .

Respuesta anterior:

Java no es la mejor opción, si va a utilizar técnicas de progtwigción funcional. Como missingfaktor escribió, tendrá que escribir una gran cantidad de código para lograr lo que quiere.

Por otro lado, no está restringido a Java en JVM; puede usar Scala o Clojure, que son lenguajes funcionales (Scala es, de hecho, funcional y OO).

Hay muchas opciones para Currying con Java 8. Tipo de función Javaslang y jOOλ ambas ofrecen Currying out of the box (creo que esto fue un descuido en el JDK), y el módulo Cyclops Functions tiene un conjunto de métodos estáticos para Currying JDK Functions y referencias de métodos. P.ej

  Curry.curry4(this::four).apply(3).apply(2).apply("three").apply("4"); public String four(Integer a,Integer b,String name,String postfix){ return name + (a*b) + postfix; } 

‘Currying’ también está disponible para los consumidores. Por ejemplo, para devolver un método con 3 params y 2 de los que ya aplicamos hacemos algo similar a este

  return CurryConsumer.curryC3(this::methodForSideEffects).apply(2).apply(2); 

Javadoc

Currying requiere devolver una función . Esto no es posible con java (sin punteros de función) pero podemos definir y devolver un tipo que contenga un método de función:

 public interface Function { // intention: f(X) -> Z public Z f(X x); } 

Ahora vamos a curry una simple división. Necesitamos un divisor :

 // f(X) -> Z public class Divider implements Function { private double divisor; public Divider(double divisor) {this.divisor = divisor;} @Override public Double f(Double x) { return x/divisor; } } 

y una función de división :

 // f(x) -> g public class DivideFunction implements Function> { @Override public function f(Double x) { return new Divider(x); } 

Ahora podemos hacer una división al curry:

 DivideFunction divide = new DivideFunction(); double result = divide.f(2.).f(1.); // calculates f(1,2) = 0.5 

Bueno, Scala , Clojure o Haskell (o cualquier otro lenguaje de progtwigción funcional …) son definitivamente los lenguajes a usar para currying y otros trucos funcionales.

Habiendo dicho eso, es posible curry con Java sin las súper cantidades de repetitivo que cabría esperar (bueno, tener que ser explícito sobre los tipos me duele mucho, solo eche un vistazo al ejemplo al curried ;-)).

Las pruebas a continuación muestran ambos, currying una Function3 en Function1 => Function1 => Function1 :

 @Test public void shouldCurryFunction() throws Exception { // given Function3 func = (a, b, c) -> a + b + c; // when Function>> cur = curried(func); // then Function> step1 = cur.apply(1); Function step2 = step1.apply(2); Integer result = step2.apply(3); assertThat(result).isEqualTo(6); } 

así como la aplicación parcial , aunque no es realmente seguro en este ejemplo:

 @Test public void shouldCurryOneArgument() throws Exception { // given Function3 adding = (a, b, c) -> a + b + c; // when Function2 curried = applyPartial(adding, _, _, put(1)); // then Integer got = curried.apply(0, 0); assertThat(got).isEqualTo(1); } 

Esto está tomado de una prueba de concepto que acabo de implementar por diversión antes de JavaOne mañana en una hora “porque estaba aburrido” 😉 El código está disponible aquí: https://github.com/ktoso/jcurry

La idea general podría ampliarse a FunctionN => FunctionM, con relativa facilidad, aunque la “seguridad de tipo real” sigue siendo un problema para el ejemplo de aplicación partia y el ejemplo de currying necesitaría muchísimo código de fuente en jcurry , pero es factible.

Con todo, es posible, pero en Scala está fuera de la caja 😉

Se puede emular el currying con Java 7 MethodHandles: http://www.tutorials.de/threads/java-7-currying-mit-methodhandles.392397/

 import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; public class MethodHandleCurryingExample { public static void main(String[] args) throws Throwable { MethodHandles.Lookup lookup = MethodHandles.lookup(); MethodHandle sum = lookup.findStatic(Integer.class, "sum", MethodType.methodType(int.class, new Class[]{int.class, int.class})); //Currying MethodHandle plus1 = MethodHandles.insertArguments(sum,0,1); int result = (int) plus1.invokeExact(2); System.out.println(result); // Output: 3 } } 

Currying es siempre posible en Java, pero no lo admite de forma estándar. Tratar de lograr esto es complicado y hace que el código sea bastante ilegible. Java no es el lenguaje apropiado para esto.

Si bien puede hacer Currying en Java, es feo (porque no es compatible). En Java es más simple y rápido usar bucles simples y expresiones simples. Si publica un ejemplo de dónde usaría currying, podemos sugerir alternativas que hagan lo mismo.

Otra opción es aquí para Java 6+

 abstract class CurFun { private Out result; private boolean ready = false; public boolean isReady() { return ready; } public Out getResult() { return result; } protected void setResult(Out result) { if (isReady()) { return; } ready = true; this.result = result; } protected CurFun getReadyCurFun() { final Out finalResult = getResult(); return new CurFun() { @Override public boolean isReady() { return true; } @Override protected CurFun apply(Object value) { return getReadyCurFun(); } @Override public Out getResult() { return finalResult; } }; } protected abstract CurFun apply(final Object value); } 

entonces podrías lograr currying de esta manera

 CurFun curFun = new CurFun() { @Override protected CurFun apply(final Object value1) { return new CurFun() { @Override protected CurFun apply(final Object value2) { return new CurFun() { @Override protected CurFun apply(Object value3) { setResult(String.format("%s%s%s", value1, value2, value3)); // return null; return getReadyCurFun(); } }; } }; } }; CurFun recur = curFun.apply("1"); CurFun next = recur; int i = 2; while(next != null && (! next.isReady())) { recur = next; next = recur.apply(""+i); i++; } // The result would be "123" String result = recur.getResult(); 

Sí, mira el ejemplo de código para ti:

 import java.util.function.Function; public class Currying { private static Function> curriedAdd = a -> b -> a+b ; public static void main(String[] args) { //see partial application of parameters Function curried = curriedAdd.apply(5); //This partial applied function can be later used as System.out.println("ans of curried add by partial application: "+ curried.apply(6)); // ans is 11 //JS example of curriedAdd(1)(3) System.out.println("ans of curried add: "+ curriedAdd.apply(1).apply(3)); // ans is 4 } } 

Este es un ejemplo simple con curriedAdd siendo una función curried que devuelve otra función, y puede usarse para la aplicación parcial de parámetros almacenados en curried, que es una función en sí misma. Esto ahora se aplica completamente cuando lo imprimimos en la pantalla.

Además, más adelante puedes ver cómo puedes usarlo en el estilo JS como

 curriedAdd.apply(1).apply(2) //in Java //is equivalent to curriedAdd(1)(2) // in JS 

Una toma más sobre las posibilidades de Java 8:

 BiFunction add = (x, y) -> x + y; Function increment = y -> add.apply(1, y); assert increment.apply(5) == 6; 

También puede definir métodos de utilidad como este:

 static  Function curry(BiFunction f, A1 a1) { return a2 -> f.apply(a1, a2); } 

Lo que le da una syntax posiblemente más legible:

 Function increment = curry(add, 1); assert increment.apply(5) == 6; 

Esta es una biblioteca para currying y aplicación parcial en Java:

https://github.com/Ahmed-Adel-Ismail/J-Curry

También es compatible con la desestructuración de Tuples y Map.Entry en los parámetros del método, como por ejemplo pasar un Map.Entry a un método que toma 2 parámetros, por lo que Entry.getKey () irá al primer parámetro, y Entry.getValue () irá por el segundo parámetro

Más detalles en el archivo README