Мне было интересно, есть ли способ вытащить это на Java. Я думаю, что это невозможно без встроенной поддержки закрытий.
Поддерживает ли Java Currying?
Ответ 1
Java 8 (выпущенный 18 марта 2014 года) поддерживает каррирование. Пример кода Java, отправленный в ответе missingfaktor, можно переписать как:
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));
}
}
... что довольно приятно. Лично, имея доступную Java 8, я вижу мало оснований использовать альтернативный язык JVM, такой как Scala или Clojure. Конечно, они предоставляют другие языковые функции, но этого недостаточно, чтобы оправдать стоимость перехода и более слабую поддержку IDE/инструментария/библиотек, IMO.
Ответ 2
Курение и частичное приложение абсолютно возможно в Java, но количество требуемого кода, вероятно, отключит вас.
Некоторый код для демонстрации currying и частичного приложения в 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 здесь эквивалент Haskell выше кода Java:
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
Ответ 3
EDIT. По состоянию на 2014 и Java 8 функциональное программирование на Java теперь не только возможно, но и не уродливо (я смею сказать красиво). См. Например ответ Рожерио.
Старый ответ:
Java не лучший выбор, если вы собираетесь использовать методы функционального программирования. Как написал missingfaktor, вам нужно будет написать довольно большой код для достижения того, чего вы хотите.
С другой стороны, вы не ограничены Java на JVM - вы можете использовать Scala или Clojure, которые являются функциональными языками (Scala, фактически, как функциональный, так и OO).
Ответ 4
Есть много вариантов для Currying с Java 8. Тип функции Javaslang и jOOλ оба предлагают Currying из коробки (я думаю, что это был надзор в JDK), и Cyclops Модуль функций содержит набор статических методов для Currying JDK Функции и ссылки на методы. Например.
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" также доступен для потребителей. Например, чтобы вернуть метод с 3 параметрами, и 2 из уже примененных, мы делаем что-то похожее на это
return CurryConsumer.curryC3(this::methodForSideEffects).apply(2).apply(2);
Ответ 5
Currying требует возврата функции. Это невозможно с помощью java (без указателей на функции), но мы можем определить и вернуть тип, содержащий метод функции:
public interface Function<X,Z> { // intention: f(X) -> Z
public Z f(X x);
}
Теперь давайте выберем простое деление. Нам нужен разделитель:
// f(X) -> Z
public class Divider implements Function<Double, Double> {
private double divisor;
public Divider(double divisor) {this.divisor = divisor;}
@Override
public Double f(Double x) {
return x/divisor;
}
}
и DivideFunction:
// f(x) -> g
public class DivideFunction implements Function<Double, Function<Double, Double>> {
@Override
public function<Double, Double> f(Double x) {
return new Divider(x);
}
Теперь мы можем сделать кардиальное деление:
DivideFunction divide = new DivideFunction();
double result = divide.f(2.).f(1.); // calculates f(1,2) = 0.5
Ответ 6
Ну, Scala, Clojure или Haskell (или любой другой язык функционального программирования...), безусловно, являются языками, используемыми для каррирования и других функциональных трюков.
Сказав, что это возможно, можно каррировать с Java без больших количеств шаблона, который можно было бы ожидать (ну, чтобы быть явным о типах, больно много - просто взгляните на пример curried;-)).
В приведенных ниже тестах показаны оба варианта: currying a Function3 в Function1 => Function1 => Function1:
@Test
public void shouldCurryFunction() throws Exception {
// given
Function3<Integer, Integer, Integer, Integer> func = (a, b, c) -> a + b + c;
// when
Function<Integer, Function<Integer, Function<Integer, Integer>>> cur = curried(func);
// then
Function<Integer, Function<Integer, Integer>> step1 = cur.apply(1);
Function<Integer, Integer> step2 = step1.apply(2);
Integer result = step2.apply(3);
assertThat(result).isEqualTo(6);
}
а также частичное приложение, хотя в этом примере оно не является типичным:
@Test
public void shouldCurryOneArgument() throws Exception {
// given
Function3<Integer, Integer, Integer, Integer> adding = (a, b, c) -> a + b + c;
// when
Function2<Integer, Integer, Integer> curried = applyPartial(adding, _, _, put(1));
// then
Integer got = curried.apply(0, 0);
assertThat(got).isEqualTo(1);
}
Это взято из доказательств концепции, которую я только что реализовал для удовольствия перед JavaOne завтра через час "потому что мне было скучно";-) Код доступен здесь: https://github.com/ktoso/jcurry
Общая идея может быть легко расширена до FunctionN = > FunctionM, хотя "реальная безопасность типов" остается проблемой для примера приложения partia, а для примера каррирования потребуется чертовски кодовый код в jcurry, но это выполнимо.
В целом, это возможно, но в Scala это из коробки; -)
Ответ 7
Можно эмулировать currying с помощью 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
}
}
Ответ 8
Currying метод всегда возможен в Java, но он не поддерживает его стандартным образом. Попытка добиться этого сложна и делает код довольно нечитаемым. Java не подходит для этого.
Ответ 9
Пока вы можете делать Currying в Java, он уродлив (потому что его не поддерживают). В Java проще и быстрее использовать простые циклы и простые выражения. Если вы разместите пример того, где вы будете использовать currying, мы можем предложить альтернативы, которые делают то же самое.
Ответ 10
Еще одно преимущество возможностей Java 8:
BiFunction<Integer, Integer, Integer> add = (x, y) -> x + y;
Function<Integer, Integer> increment = y -> add.apply(1, y);
assert increment.apply(5) == 6;
Вы также можете определить методы утилиты, подобные этой:
static <A1, A2, R> Function<A2, R> curry(BiFunction<A1, A2, R> f, A1 a1) {
return a2 -> f.apply(a1, a2);
}
Что дает вам более читаемый синтаксис:
Function<Integer, Integer> increment = curry(add, 1);
assert increment.apply(5) == 6;
Ответ 11
Другой вариант здесь для Java 6 +
abstract class CurFun<Out> {
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<Out> getReadyCurFun() {
final Out finalResult = getResult();
return new CurFun<Out>() {
@Override
public boolean isReady() {
return true;
}
@Override
protected CurFun<Out> apply(Object value) {
return getReadyCurFun();
}
@Override
public Out getResult() {
return finalResult;
}
};
}
protected abstract CurFun<Out> apply(final Object value);
}
тогда вы могли бы добиться каррирования таким образом
CurFun<String> curFun = new CurFun<String>() {
@Override
protected CurFun<String> apply(final Object value1) {
return new CurFun<String>() {
@Override
protected CurFun<String> apply(final Object value2) {
return new CurFun<String>() {
@Override
protected CurFun<String> apply(Object value3) {
setResult(String.format("%s%s%s", value1, value2, value3));
// return null;
return getReadyCurFun();
}
};
}
};
}
};
CurFun<String> recur = curFun.apply("1");
CurFun<String> 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();
Ответ 12
Да, посмотрите пример кода для себя:
import java.util.function.Function;
public class Currying {
private static Function<Integer, Function<Integer,Integer>> curriedAdd = a -> b -> a+b ;
public static void main(String[] args) {
//see partial application of parameters
Function<Integer,Integer> 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
}
}
Это простой пример, в котором curriedAdd является функцией карри, которая возвращает другую функцию, и это можно использовать для частичного применения параметров, хранящихся в карри, которая сама по себе является функцией. Это теперь позже применяется полностью, когда мы печатаем это на экране.
Более того, позже вы можете увидеть, как вы можете использовать его в стиле JS как
curriedAdd.apply(1).apply(2) //in Java
//is equivalent to
curriedAdd(1)(2) // in JS
Ответ 13
Это библиотека для карри и частичного применения в Java:
https://github.com/Ahmed-Adel-Ismail/J-Curry
Он также поддерживает деструктуризацию Tuples и Map.Entry в параметры метода, как, например, передача Map.Entry методу, который принимает 2 параметра, поэтому Entry.getKey() перейдет к первому параметру, а Entry.getValue() будет идти по второму параметру
Подробнее в файле README
Ответ 14
Преимущество использования Curry в Java 8 состоит в том, что он позволяет вам определять функции высокого порядка, а затем передавать функцию первого порядка и аргументы функции в элегантной цепочке.
Вот пример для исчисления, производной функции.
- Давайте определим приближение производной функции как (f (x + h) -f (x))/h. Это будет функция высшего порядка
- Давайте вычислим производную от 2 различных функций, 1/х, и стандартизированное распределение Гаусса
package math;
import static java.lang.Math.*;
import java.util.Optional;
import java.util.function.*;
public class UnivarDerivative
{
interface Approximation extends Function<Function<Double,Double>,
Function<Double,UnaryOperator<Double>>> {}
public static void main(String[] args)
{
Approximation derivative = f->h->x->(f.apply(x+h)-f.apply(x))/h;
double h=0.00001f;
Optional<Double> d1=Optional.of(derivative.apply(x->1/x).apply(h).apply(1.0));
Optional<Double> d2=Optional.of(
derivative.apply(x->(1/sqrt(2*PI))*exp(-0.5*pow(x,2))).apply(h).apply(-0.00001));
d1.ifPresent(System.out::println); //prints -0.9999900000988401
d2.ifPresent(System.out::println); //prints 1.994710003159016E-6
}
}
Ответ 15
Да, я согласен с @Jérôme, curring в Java 8 не поддерживается стандартным способом, как в Scala или других функциональных языках программирования.
public final class Currying {
private static final Function<String, Consumer<String>> MAILER = (String ipAddress) -> (String message) -> {
System.out.println(message + ":" + ipAddress );
};
//Currying
private static final Consumer<String> LOCAL_MAILER = MAILER.apply("127.0.0.1");
public static void main(String[] args) {
MAILER.apply("127.1.1.2").accept("Hello !!!!");
LOCAL_MAILER.accept("Hello");
}
}