groovy-closure-currying

Overview of groovy closure currying.

Reference: https://www.jstips.co/en/javascript/curry-vs-partial-application/
Reference: https://en.wikipedia.org/wiki/Currying
Reference: https://en.wikipedia.org/wiki/Partial_application
Reference: https://en.wikipedia.org/wiki/Arity

preface

currying

In mathematics and computer science, currying is the technique of
translating the evaluation of a function that takes multiple
arguments into evaluating a sequence of functions, each with a
single argument. For example, a function that takes two arguments,
one from X and one from Y, and produces outputs in Z, by currying
is translated into a function that takes a single argument from X
and produces as outputs functions from Y to Z. Currying is related
to, but not the same as, partial application.

example

add: X x X -> X

  function add(x, y) {
    return x + y;
  }

curried add: X -> (X -> X)

  function curriedAdd(x) {
    return function (y) {
      return x + y;
    }
  }

calling:
```
  add(3, 5);
  curriedAdd(3)(5);
```

partial application

In computer science, partial application (or partial function application)
refers to the process of fixing a number of arguments to a function,
producing another function of smaller arity (arity of a function or
operation is the number of arguments or operands that the function takes).

example

add: X x X -> X

  function add(x, y) {
    return x + y;
  }

partial add: X -> X

  function partialAdd_5(y) {
    return add(5, y);
  }

calling:
```
  add(5, 3);
  partialAdd_5(3);
```

currying vs partial application

currying

Currying takes a function

f: X x Y -> R

and turns it into a function

f': X -> (Y -> R)

Thus, if the uncurried f is invoked as

f(3,5)

then the curried f’ is invoked as

f'(3)(5)
partial application

Partial application takes a function

f: X x Y -> R

and a fixed value for the first argument to produce a new function

f': Y -> R

f’ does the same as f, but only has to fill in the second
parameter which is why its arity is one less than the arity of f.

groovy currying

In Groovy, currying refers to the concept of partial application.
It does not correspond to the real concept of currying in functional
programming because of the different scoping rules that Groovy
applies on closures.

Please refer my other github project:
https://github.com/mtumilowicz/groovy-closure-owner-delegate-this

Currying in Groovy will let you set the
value of one parameter of a closure, and it will return a new
closure accepting one less argument.

It is quite useful with .& operator:
https://github.com/mtumilowicz/groovy-transform-method-to-closure

We have 3 approaches to currying in groovy:

Left currying - setting the left-most parameter of a closure
Right currying - setting the right-most parameter of a closure
Index based currying - In case a closure accepts more than
2 parameters, it is possible to set an arbitrary parameter using ncurry

project description

We provide tests in Currying class:

left currying

  given:
  def divide = { x, y -> x / y }
  when:
  def curriedDivide = divide.curry(10)
  then:
  curriedDivide(2) == 5

right currying

  given:
  def divide = { x, y -> x / y }
  when:
  def curriedDivide = divide.rcurry(10)
  then:
  curriedDivide(20) == 2

index based currying

  given:
  def concat = { a, b, c, d, e -> String.join(",", a, b, c, d, e) }
  when:
  def currierConcat = concat.ncurry(2, "c", "d", "e")
  then:
  currierConcat("a", "b") == "a,b,c,d,e"

currying with method reference

  given:
  def curriedAdd = Currying.&add.curry(5)
  expect:
  curriedAdd(2) == 7

where:

  static int add(x, y) {
      return x + y
  }