Currying: Difference between revisions

[[Category:Functions and subroutines]]

<br><br>

 

=={{header|Ada}}==

 

Support package spec:

type Argument_1 (<>) is limited private;

type Argument_2 (<>) is limited private;

end Apply_1;

 

 

Support package body:

 

package body Apply_1 is

end Apply_1;

 

 

Currying a function:

 

procedure Curry_Test is

Ada.Text_IO.Put_Line ("Five plus seven plus three is" & Integer'Image (Result));

 

 

Output:

=={{header|Aime}}==

Curry a function printing an integer, on a given number of characters, with commas inserted every given number of digits, with a given number of digits, in a given base:

{

l[0] = apply.apply(l[0]);

0;

}

{{out}}

<pre> 000,040,000,000</pre>

=={{header|ALGOL 68}}==

In 1968 [[wp:Charles H. Lindsey|C.H. Lindsey]] proposed for '''partial parametrisation''' for ALGOL 68, this is implemented as an extension in [[wp:ALGOL 68G]].

 

MODE FUN = PROC (REAL) REAL;

 

REAL x = read real;

 

=={{header|AppleScript}}==

The nearest thing to a first-class function in AppleScript is a 'script' in which a 'handler' (with some default or vanilla name like 'call' or 'lambda') is embedded. First class use of an ordinary 2nd class 'handler' function requires 'lifting' it into an enclosing script – a process which can be abstracted to a general mReturn function.

 

on curry(f)

script

end script

end if

{{Out}}

<pre>{«script», «script», 5, {7, 14, 21, 28, 35, 42, 49, 56, 63, 70}}</pre>

 

=={{header|C}}==

#include<stdarg.h>

#include<stdio.h>

return 0;

}

Output:

<pre>

</pre>

 

This shows how to create syntactically natural currying functions in [[C sharp|C#]].

public delegate Plus CurriedPlus(int x);

public static CurriedPlus plus =

int sum = plus(3)(4); // sum = 7

int sum2= plus(2)(plus(3)(4)) // sum2 = 9

 

=={{header|C++}}==

=={{header|Ceylon}}==

{{trans|Groovy}}

function divide(Integer x, Integer y) => x / y;

a third is ``partsOf120(3)``

and a quarter is ``partsOf120(4)``");

 

=={{header|Clojure}}==

(assert (=

(plus-a-hundred 1)

101))

 

=={{header|Common Lisp}}==

(lambda (&rest args-2)

(apply function (append args-1 args-2))))

 

Usage:

(funcall (curry #'+ 10) 10)

 

20

 

=={{header|Crystal}}==

Crystal allows currying procs with either <code>Proc#partial</code> or by manually creating closures:

 

add_curried = add_things.partial(2, 3)

add_curried.call(4) #=> 9

end

add13 = add_two_things(3).call(10)

 

=={{header|D}}==

import std.stdio, std.functional;

 

writeln("Add 2 to 3: ", add(2, 3));

writeln("Add 2 to 3 (curried): ", add2(3));

{{out}}

<pre>Add 2 to 3: 5

{{libheader| System.SysUtils}}

{{Trans|C#}}

program Currying;

 

readln;

end.

{{out}}

<pre>

9

</pre>

=={{header|EchoLisp}}==

;;

;; curry functional definition

(curry * 2 3 (+ 2 2))

→ (λ _#:g1004 (#apply-curry #* (2 3 4) _#:g1004))

 

=={{header|Eero}}==

 

int main()

 

return 0

Alternative implementation (there are a few ways to express blocks/lambdas):

 

int main()

 

return 0

 

=={{header|Eiffel}}==

 

where FUNCTION [ANY, TUPLE [Y], Z] denotes the type ''Y'' → ''Z'' (agents taking as argument a tuple with a single argument of type Y and returning a result of type Z), which is indeed the type of the agent expression used on the next-to-last line to define the "Result" of g.

 

=={{header|Erlang}}==

There are three solutions provided for this problem. The simple version is using anonymous functions as other examples of other languages do. The second solution corresponds to the definition of currying. It takes a function of a arity ''n'' and applies a given argument, returning then a function of arity ''n-1''. The solution provided uses metaprogramming facilities to create the new function. Finally, the third solution is a generalization that allows to curry any number of parameters and in a given order.

 

-module(currying).

 

erlang:error(badarg)

end.

 

 

F# is largely based on ML and has a built-in natural method of defining functions that are curried:

 

 

 

val add2 : (int -> int)

val it : (int -> int) = <fun:addN@1>

> add2 7;;

 

=={{header|Factor}}==

 

--- Data stack:

 

--- Data stack:

Currying doesn't need to be an atomic operation. <tt>compose</tt> lets you combine quotations.

 

--- Data stack:

--- Data stack:

3

 

You can even treat quotations as sequences.

 

--- Data stack:

 

Finally, fried quotations are often clearer than using <tt>curry</tt> and <tt>compose</tt>. Use <tt>_</tt> to take objects from the stack and slot them into the quotation.

IN: scratchpad 2 3 '[ _ _ + ]

 

--- Data stack:

 

Use <tt>@</tt> to insert the contents of a quotation into another quotation.

 

--- Data stack:

 

=={{header|Forth}}==

{{trans|Common Lisp}}

swap 2>r :noname r> postpone literal r> compile, postpone ; ;

 

5 ' + curry constant +5

5 +5 execute .

 

{{out}}

<pre>10 12</pre>

 

 

 

 

 

 

 

 

 

 

 

=={{header|Go}}==

[http://golang.org/ref/spec#Method_values Method values] were added

in [http://golang.org/doc/go1.1#method_values Go 1.1].

 

import (

fmt.Println("2 + 4 =", fn2(a, 4))

fmt.Println("3 + 5 =", fn2(Foo(3), 5))

[http://play.golang.org/p/0YL9YTe-9V Run on the Go Playground.]

 

 

Example:

x / y

}

def partsOf120 = divide.curry(120)

 

 

Results:

 

Example (using the same "divide()" closure as before):

def third = divide.rcurry(3)

def quarter = divide.rcurry(4)

 

 

Results:

 

=={{header|Haskell}}==

Prelude> let plus = \x y -> x + y

8

 

 

Prelude> let nested_plus = \x -> \y -> x + y

 

=={{header|Hy}}==

(fn [x]

=> (add2 7)

9

 

=> ((addN 3) 4)

 

==Icon and {{header|Unicon}}==

used.

 

add2 := addN(2)

write("add2(7) = ",add2(7))

procedure makeProc(A)

return (@A[1], A[1])

 

{{Out}}

=={{header|Io}}==

A general currying function written in the [[Io]] programming language:

a := call evalArgs slice(1)

block(

increment := curry( method(a,b,a+b), 1 )

increment call(5)

 

=={{header|J}}==

 

'''Solution''':Use <tt>&</tt> (bond). This primitive conjunction accepts two arguments: a function (verb) and an object (noun) and binds the object to the function, deriving a new function.

threePlus 7

10

halve 20

10

 

'''Note''': The final example (<tt>someParabola</tt>) shows the single currying primitive (&) combined with J's array oriented nature, permits partial application of a function of any number of arguments.

 

=={{header|Java}}==

public interface CurriableFunctor<ARG1, ARG2, RET> {

RET evaluate(ARG1 arg1, ARG2 arg2);

System.out.println(add5.evaluate(new Integer(2)));

}

 

===Java 8===

 

import java.util.function.BiFunction;

import java.util.function.Function;

}

}

 

=={{header|JavaScript}}==

 

====Partial application====

var curry = function(x) {

return x + n;

add2 = addN(2);

alert(add2);

 

====Generic currying====

Basic case - returning a curried version of a function of two arguments

 

 

// curry :: ((a, b) -> c) -> a -> b -> c

 

})();

 

{{Out}}

 

 

Functions of arbitrary arity can also be curried:

 

 

// (arbitrary arity to fully curried)

// [14, 28, 42, 56, 70, 84, 98, 112, 126, 140]

 

 

{{Out}}

 

===ES6===

 

====Y combinator====

 

One version for functions of a set amount of arguments that takes no rest arguments, and one version for functions with rest argument. The caveat being that if the rest argument would be empty, it still requires a separate application, and multiple rest arguments cannot be curried into multiple applications, since we have to figure out the number of applications from the function signature, not the amount of arguments the user might want to send it.

fix = // This is a variant of the Applicative order Y combinator

f => (f => f(f))(g => f((...a) => g(g)(...a))),

print(curriedmax(8)(4),curryrestedmax(8)(4)(),curryrestedmax(8)(4)(9,7,2));

// 8,8,9

Neither of these handle propagation of the this value for methods, as ECMAScript 2015 (ES6) fat arrow syntax doesn't allow for this value propagation. Versions could easily be written for those cases using an outer regular function expression and use of Function.prototype.call or Function.prototype.apply. Use of Y combinator could also be removed through use of an inner named function expression instead of the anonymous fat arrow function syntax.

 

In the most rudimentary form, for example for mapping a two-argument function over an array:

 

 

// curry :: ((a, b) -> c) -> a -> b -> c

// [7, 14, 21, 28, 35, 42, 49, 56, 63, 70]

 

 

{{Out}}

 

 

Or, recursively currying functions of arbitrary arity:

 

 

// (arbitrary arity to fully curried)

// [14, 28, 42, 56, 70, 84, 98, 112, 126, 140]

 

 

{{Out}}

 

=={{header|jq}}==

 

In jq, functions are filters. Accordingly, we illustrate currying by defining plus(x) to be a filter that adds x to its input, and then define plus5 as plus(5):

def plus(x): . + x;

 

def plus5: plus(5);

 

 

=={{header|Julia}}==

function addN(n::Number)::Function

adder(x::Number) = n + x

return adder

end

 

{{out}}

 

</pre>

 

=={{header|Kotlin}}==

 

fun curriedAdd(x: Int) = { y: Int -> x + y }

val sum = curriedAdd(a)(b)

println("$a + $b = $sum")

 

{{out}}

=={{header|Lambdatalk}}==

Called with a number of values lesser than the number of arguments a function memorizes the given values and returns a function waiting for the missing ones.

1) just define function a binary function:

{def power {lambda {:a :b} {pow :a :b}}}

{S.map {power 2} {S.serie 1 10}} // S.map applies the {power 2} unary function

-> 2 4 8 16 32 64 128 256 512 1024 // to a sequence of numbers from 1 to 10

 

=={{header|Latitude}}==

 

takes '[n].

{

 

add3 := addN 3.

 

Note that, because of the syntax of the language, it is not possible to call <code>addN</code> in one line the naive way.

;; (addN (3)) (4). ;; Syntax error!

 

As a consequence, it is more common in Latitude to return new objects whose methods have meaningful names, rather than returning a curried function.

takes '[n].

Object clone tap {

}.

 

 

=={{header|LFE}}==

(lambda (x)

(apply f

(list arg x))))

Usage:

(funcall (curry #'+/2 10) 10)

 

=={{header|Logtalk}}==

| ?- logtalk << call([Z]>>(call([X,Y]>>(Y is X*X), 5, R), Z is R*R), T).

T = 625

yes

 

Logtalk support for lambda expressions and currying was introduced in version 2.38.0, released in December 2009.

 

=={{header|Lua}}==

function curry2(f)

return function(x)

assert(add2(3) == 2+3)

assert(add2(5) == 2+5)

=== another implementation ===

Proper currying, tail call without array packing/unpack.

local curry do

local call,env = function(fn,...)return fn(...)end

assert(add2(3) == 2+3)

assert(add2(5) == 2+5)

 

=={{header|M2000 Interpreter}}==

divide=lambda (x, y)->x/y

Print "half of 120 is ";partsof120(2)

Print "a third is ";partsof120(3)

Print "and a quarter is ";partsof120(4)

}

 

Module Joke {

}

Joke

Without joke, can anyone answer this puzzle?

Module Puzzle {

Global Group F2 {

}

Puzzle

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Out[5]:= 5

</pre>

 

=={{header|Nemerle}}==

Currying isn't built in to Nemerle, but is relatively straightforward to define.

using System.Console;

WriteLine($"$(h(30))")

}

 

=={{header|Nim}}==

 

let add2 = addN(2)

Alternative syntax:

 

proc addM[T](n: T): auto = (x: T) => x + n

 

let add3 = addM(3)

 

=={{header|OCaml}}==

OCaml has a built-in natural method of defining functions that are curried:

 

let add1 = addnums 1 (* bind the first argument to get another function *)

The type of <code>addnums</code> above will be <tt>int -> int -> int</tt>.

 

 

You can also define a general currying higher-ordered function:

This is a function that takes a function as a parameter and returns a function that takes one of the parameters and returns ''another'' function that takes the other parameter and returns the result of applying the parameter function to the pair of arguments.

 

=={{header|Oforth}}==

 

5 2+ .

 

=={{header|Ol}}==

(define (addN n)

(lambda (x) (+ x n)))

(print "(add10 4) ==> " (add10 4))

(print "(add20 4) ==> " (add20 4)))

{{out}}

<pre>

=={{header|PARI/GP}}==

Simple currying example with closures.

{{out}}

<pre>3</pre>

=={{header|Perl}}==

This is a [[Perl|Perl 5]] example of a general curry function and curried plus using [[wp:closure (computer science)|closures]]:

my ($func, @args) = @_;

 

 

my $plusXOne = curry(\&plusXY, 1);

 

=={{header|Phix}}==

Phix does not support currying. The closest I can manage is very similar to my solution for closures

{{out}}

<pre>

 

=={{header|PHP}}==

 

function curry($callable)

}

 

{{out}}<pre>[7,14,21,28,35,42,49,56,63,70]</pre>

 

 

=={{header|PowerShell}}==

function Add($x) { return { param($y) return $y + $x }.GetNewClosure() }

& (Add 1) 2

{{Out}}

<pre>

</pre>

Add each number in list to its square root:

(4,9,16,25 | ForEach-Object { & (add $_) ([Math]::Sqrt($_)) }) -join ", "

{{Out}}

<pre>

===Nested defs and functools.partial===

Since Python has had local functions with closures since around 1.0, it's always been possible to create curried functions manually:

def adder(x):

return x + n

 

>>> add2

<function adder at 0x009F1E30>

>>> add2(7)

 

But Python also comes with a function to build partial functions (with any number of positional or keyword arguments bound in) for you. This was originally in a third-party model called functional, but was added to the stdlib functools module in 2.5. Every year or so, someone suggests either moving it into builtins because it's so useful or removing it from the stdlib entirely because it's so easy to write yourself, but it's been in the functools module since 2.5 and will probably always be there.

>>> from operator import add

>>> add2 = partial(add, 2)

>>> double = partial(map, lambda x: x*2)

>>> print(*double(range(5)))

 

But for a true curried function that can take arguments one at a time via normal function calls, you have to do a bit of wrapper work to build a callable object that defers to partial until all of the arguments are available. Because of the Python's dynamic nature and flexible calling syntax, there's no way to do this in a way that works for every conceivable valid function, but there are a variety of ways that work for different large subsets. Or just use a third-party library like [https://toolz.readthedocs.io toolz] that's already done it for you:

>>> import operator

>>> add = curry(operator.add)

>>> double = map(lambda x: x*2)

>>> print(*double(range(5)))

 

===Automatic curry and uncurry functions using lambdas===

We can also write a general '''curry''' function, and a corresponding '''uncurry''' function, for automatic derivation of curried and uncurried functions at run-time, without needing to import ''functools.partial'':

 

 

 

 

 

{{Out}}

<pre>Manually curried using a lambda:

In the second example we drop the 8 from the previous example from the stack and then use currying to join "lamb" to "balti".

 

 

{{out}}

lamb balti

Stack empty.

</pre>

 

The simplest way to make a curried functions is to use curry:

 

#lang racket

(((curry +) 3) 2) ; =>5

 

As an alternative, one can use the following syntax:

#lang racket

 

 

((curried+ 3) 2) ; => 5

 

=={{header|Raku}}==

(formerly Perl 6)

All callable objects have an "assuming" method that can do partial application of either positional or named arguments. Here we curry the built-in subtraction operator.

{{out}}

<pre>-1</pre>

This example is modeled after the &nbsp; '''D''' &nbsp; example.

===specific version===

say 'add 2 to 3: ' add(2, 3)

say 'add 2 to 3 (curried):' add2(3)

/*──────────────────────────────────────────────────────────────────────────────────────*/

add: procedure; $= arg(1); do j=2 to arg(); $= $ + arg(j); end; return $

{{out|output|text=&nbsp; when using the defaults:}}

<pre>

 

===generic version===

say 'add 2 to 3: ' add(2, 3)

say 'add 2 to 3 (curried):' add2(3)

return $

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}} <br><br>

 

=={{header|Ruby}}==

The curry method was added in Ruby 1.9.1. It takes an optional arity argument, which determines the number of arguments to be passed to the proc.

If that number is not reached, the curry method returns a new curried method for the rest of the arguments. (Examples taken from the documentation).

b = proc {|x, y, z| (x||0) + (y||0) + (z||0) }

p b.curry[1][2][3] #=> 6

p b.curry(5)[1, 2][3, 4][5] #=> 15

p b.curry(1)[1] #=> 1

 

=={{header|Rust}}==

 

This is a simple currying function written in [[Rust]]:

move |x| n + x

}

let adder = add_n(40);

println!("The answer to life is {}.", adder(2));

 

=={{header|Scala}}==

def add(a: Int)(b: Int) = a + b

val add5 = add(5) _

add5(2)

 

=={{header|Sidef}}==

This can be done by using lazy methods:

 

Or by using a generic curry function:

func (*args2) {

f(args1..., args2...);

 

var adder = curry(add, 1);

 

=={{header|Standard ML}}==

Standard ML has a built-in natural method of defining functions that are curried:

 

val add1 = addnums 1 (* bind the first argument to get another function *)

The type of <code>addnums</code> above will be <tt>int -> int -> int</tt> (the type constraint in the declaration only being necessary because of the polymorphic nature of the <code>+</code> operator).

 

 

You can also define a general currying higher-ordered function:

This is a function that takes a function as a parameter and returns a function that takes one of the parameters and returns ''another'' function that takes the other parameter and returns the result of applying the parameter function to the pair of arguments.

 

=={{header|Swift}}==

You can return a closure (or nested function):

 

var add2 = addN(2)

println(add2) // (Function)

 

Prior to Swift 3, there was a curried function definition syntax:

 

var add2 = addN(2)

println(add2) // (Function)

However, there was a bug in the above syntax which forces the second parameter to always be labeled. As of Swift 1.2, you could explicitly make the second parameter not labeled:

 

var add2 = addN(2)

println(add2) // (Function)

 

=={{header|Tcl}}==

The simplest way to do currying in Tcl is via an interpreter alias:

Tcl doesn't support automatic creation of curried functions though; the general variadic nature of a large proportion of Tcl commands makes that impractical.

===History===

A two-argument function which subtracts is arguments from 10, and then subtracts five:

 

 

TXR Lisp doesn't have a predefined function or operator for currying. A function can be manually curried. For instance, the three-argument named function: <code>(defun f (x y z) (* (+ x y) z))</code> can be curried by hand to produce a function <code>g</code> like this:

 

(lambda (y)

(lambda (z)

 

Or, by referring to the definition of <code>f</code>:

 

(lambda (y)

(lambda (z)

 

Since a three-argument function can be defined directly, and has advantages like diagnosing incorrect calls which pass fewer than three or more than three arguments, currying is not useful in this language. Similar reasoning applies as given in the "Why not real currying/uncurrying?" paragraph under the Design Rationale of Scheme's SRFI 26.

 

=={{header|Vala}}==

 

Dbl_Op curried_add(double a) {

double sum2 = curried_add(2.0) (curried_add(3.0)(4.0)); //sum2 = 9

print(@"$sum2\n");

{{out}}

<pre>

9

</pre>

 

=={{header|Wortel}}==

The <code>\</code> operator takes a function and an argument and partial applies the argument to the function. The <code>&\</code> works like the <code>\</code> operator but can also take an array literal and partial applies all the arguments in the array.

addOne \+ 1

subtractFrom1 \- 1

!addOne_2 5 ; returns 6

]]

 

=={{header|Wren}}==

{{trans|Rust}}

 

var adder = addN.call(40)

 

{{out}}

The answer to life is 42.

</pre>

 

=={{header|zkl}}==

zkl doesn't support currying per se (recompilation of f with fixed input to create a new function), it does support partial application, for all objects, for any [number of] positional parameters to create an object of reduced arity.

minusOne:=Op("-").fp1(1); minusOne(5) //-->4, note that this fixed 1 as the second parameter

// fix first and third parameters:

foo:=String.fpM("101","<foo>","</foo>"); foo("zkl"); //-->"<foo>zkl</foo>"

fcn g(x){x+1} f:=fcn(f,x){f(x)+x}.fp(g); f(5); //-->11