Java 8 Lambda ve Currying

Currying Kullanımı

Currying kelimesinin Türkçesi nedir bilmiyorum. Verilen parametreyi işleyen bir başka metod dönülmesi anlamına geliyor.

Örnek - Type Safety

Şöyle yaparız. Bu metod @FunctionalInterface olarak işaretli bir io.vertx.core.Handler döndürüyor. Döndürülen şey Handler<Message<T>> tipinden. Handler io.vertx.core.eventbus.Message tipinden bir nesne alır.

Dolayısıyla Handler.handle() metoduna geçilen message parametresi Message<T> tipinden.

public static <T> Handler<Message<T>> matching(Class<T> match,
                                               Handler<Message<T>> consumer) {
  return message -> {
    T body = message.body();
    if (match.isInstance(body) {
       handler.handler(body);
    }
  };
}

Örnek
Verilen parametreyi işleyen bir başka metod döner. Şöyle yaparız.

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

g'yi çağırmak için şöyle yaparız.

Function<Integer, Integer> plus10 = g.apply (10);

Daha sonra şöyle yaparız.

Integer result = plus10.apply (5); // 15

Örnek
Şöyle yaparız. Burada builder() metodu biraz karışık. Lambda döndüren lambda gibi. Aslında anonymous sınıf döndüren metod gibi düşünmel anlamayı daha kolay yapabilir.

SimpleBean.builder().index(1).name("name") gibi kullanılır. builder() bir Builder döner. Bu sınıfın tek metodu ise index()'tir. Bu çağrı da Stage1 nesnesi döner. Bu sınıfın da tek metodu name()'dir.

public class SimpleBean {

  private final int index;
  private final String name;

  private SimpleBean(final int index, final String name) {
    this.index = index;
    this.name = name;
  }

  public int index() {
    return index;
  }

  public String name() {
    return name;
  }

  public static Builder builder() {
    return index -> name -> new SimpleBean(index, name);
  }

  public interface Builder {
    Stage1 index(int index);
      interface Stage1 {
        SimpleBean name(final String name);
      }
  }
}