Currying: Difference between revisions
| Line 542: | Line 542: | ||
Curring is possible, but it is not a built-in part of the language. |
Curring is possible, but it is not a built-in part of the language. |
||
<lang Oforth>func: curry(f, n) { #[ n f perform ] } |
<lang Oforth>func: curry(f, n) { #[ n f perform ] }</lang> |
||
Usage : |
|||
| ⚫ | |||
| ⚫ | |||
{ |
{ |
||
| plus2 | |
| plus2 | |
||
Revision as of 10:00, 7 February 2015
You are encouraged to solve this task according to the task description, using any language you may know.
| This page uses content from Wikipedia. The original article was at Currying. The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance) |
Create a simple demonstrative example of Currying in the specific language.
Add any historic details as to how the feature made its way into the language.
ALGOL 68
In 1968 C.H. Lindsey proposed for partial parametrisation for ALGOL 68, this is implemented as an extension in wp:ALGOL 68G. <lang algol68># Raising a function to a power #
MODE FUN = PROC (REAL) REAL; PROC pow = (FUN f, INT n, REAL x) REAL: f(x) ** n; OP ** = (FUN f, INT n) FUN: pow (f, n, );
- Example: sin (3 x) = 3 sin (x) - 4 sin^3 (x) (follows from DeMoivre's theorem) #
REAL x = read real; print ((new line, sin (3 * x), 3 * sin (x) - 4 * (sin ** 3) (x)))</lang>
C#
This shows how to create syntactically natural currying functions in C#. <lang csharp>public delegate int Plus(int y); public delegate Plus CurriedPlus(int x); public static CurriedPlus plus =
delegate(int x) {return delegate(int y) {return x + y;};};
static void Main() {
int sum = plus(3)(4); // sum = 7 int sum2= plus(2)(plus(3)(4)) // sum2 = 9
}</lang>
C++
Currying may be achieved in C++ using the Standard Template Library function object adapters (binder1st and binder2nd), and more generically using the Boost bind mechanism.
Common Lisp
<lang lisp>(defun curry (function &rest args-1)
(lambda (&rest args-2) (apply function (append args-1 args-2))))
</lang>
Usage: <lang lisp> (funcall (curry #'+ 10) 10)
20 </lang>
D
<lang d>void main() {
import std.stdio, std.functional;
int add(int a, int b) {
return a + b;
}
alias add2 = curry!(add, 2);
writeln("Add 2 to 3: ", add(2, 3));
writeln("Add 2 to 3 (curried): ", add2(3));
}</lang>
- Output:
Add 2 to 3: 5 Add 2 to 3 (curried): 5
Eero
<lang objc>#import <stdio.h>
int main()
addN := (int n)
int adder(int x)
return x + n
return adder
add2 := addN(2)
printf( "Result = %d\n", add2(7) )
return 0
</lang> Alternative implementation (there are a few ways to express blocks/lambdas): <lang objc>#import <stdio.h>
int main()
addN := (int n) return (int x | return x + n)
add2 := addN(2)
printf( "Result = %d\n", add2(7) )
return 0
</lang>
Eiffel
Eiffel has direct support for lambda expressions and hence currying through "inline agents". If f is a function with two arguments, of signature (X × Y) → Z then its curried version is obtained by simply writing
g (x: X): FUNCTION [ANY, TUPLE [Y], Z]
do
Result := agent (closed_x: X; y: Y): Z
do
Result := f (closed_x, y)
end (x, ?)
end
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.
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.
<lang erlang> -module(currying).
-compile(export_all).
% Function that curry the first or the second argument of a given function of arity 2
curry_first(F,X) ->
fun(Y) -> F(X,Y) end.
curry_second(F,Y) ->
fun(X) -> F(X,Y) end.
% Usual curry
curry(Fun,Arg) -> case erlang:fun_info(Fun,arity) of {arity,0} -> erlang:error(badarg); {arity,ArityFun} -> create_ano_fun(ArityFun,Fun,Arg); _ -> erlang:error(badarg) end.
create_ano_fun(Arity,Fun,Arg) -> Pars = [{var,1,list_to_atom(lists:flatten(io_lib:format("X~p", [N])))} || N <- lists:seq(2,Arity)], Ano = {'fun',1, {clauses,[{clause,1,Pars,[], [{call,1,{var,1,'Fun'},[{var,1,'Arg'}] ++ Pars}]}]}}, {_,Result,_} = erl_eval:expr(Ano, [{'Arg',Arg},{'Fun',Fun}]), Result.
% Generalization of the currying
curry_gen(Fun,GivenArgs,PosGivenArgs,PosParArgs) ->
Pos = PosGivenArgs ++ PosParArgs,
case erlang:fun_info(Fun,arity) of
{arity,ArityFun} ->
case ((length(GivenArgs) + length(PosParArgs)) == ArityFun) and
(length(GivenArgs) == length(PosGivenArgs)) and
(length(Pos) == sets:size(sets:from_list(Pos))) of
true ->
fun(ParArgs) ->
case length(ParArgs) == length(PosParArgs) of
true ->
Given = lists:zip(PosGivenArgs,GivenArgs),
Pars = lists:zip(PosParArgs,ParArgs),
{_,Args} = lists:unzip(lists:sort(Given ++ Pars)),
erlang:apply(Fun,Args);
false ->
erlang:error(badarg)
end
end;
false ->
erlang:error(badarg)
end;
_ ->
erlang:error(badarg)
end.
</lang>
Output (simple version):
> (currying:curry_first(fun(X,Y) -> X + Y end,3))(2). 5 > (currying:curry_first(fun(X,Y) -> X - Y end,3))(2). 1 > (currying:curry_second(fun(X,Y) -> X - Y end,3))(2). -1
Output (usual curry):
> G = fun(A,B,C)-> (A + B) * C end. #Fun<erl_eval.18.90072148> > (currying:curry(G,3))(2,1). 5 > (currying:curry(currying:curry(G,3),2))(1). 5 > (currying:curry(currying:curry(currying:curry(G,3),2),1))(). 5
Output (generalized version):
> (currying:curry_gen(fun(A,B,C,D) -> (A + B) * (C - D) end,[1.0,0.0],[1,2],[3,4]))([2.0,5.0]). -3.0 > (currying:curry_gen(fun(A,B,C,D) -> (A + B) * (C - D) end,[1.0,0.0],[4,2],[1,3]))([2.0,5.0]). 8.0 > (currying:curry_gen(fun(A,B,C) -> (A + B) * C end,[1.0,0.0],[3,2],[1]))([5.0]). 5.0
F#
<lang fsharp>let addN n = (+) n</lang>
<lang fsharp>> let add2 = addN 2;;
val add2 : (int -> int)
> add2;; val it : (int -> int) = <fun:addN@1> > add2 7;; val it : int = 9</lang>
Forth
<lang forth>: curry ( x xt1 -- xt2 )
swap 2>r :noname r> postpone literal r> compile, postpone ; ;
5 ' + curry constant +5 5 +5 execute . 7 +5 execute .</lang>
- Output:
10 12
Go
Go has had function literals and method expressions since before Go 1.0. Method values were added in Go 1.1. <lang go>package main
import (
"fmt"
"math"
)
func PowN(b float64) func(float64) float64 {
return func(e float64) float64 { return math.Pow(b, e) }
}
func PowE(e float64) func(float64) float64 {
return func(b float64) float64 { return math.Pow(b, e) }
}
type Foo int
func (f Foo) Method(b int) int {
return int(f) + b
}
func main() {
pow2 := PowN(2)
cube := PowE(3)
fmt.Println("2^8 =", pow2(8))
fmt.Println("4³ =", cube(4))
var a Foo = 2
fn1 := a.Method // A "method value", like currying 'a'
fn2 := Foo.Method // A "method expression", like uncurrying
fmt.Println("2 + 2 =", a.Method(2)) // regular method call
fmt.Println("2 + 3 =", fn1(3))
fmt.Println("2 + 4 =", fn2(a, 4))
fmt.Println("3 + 5 =", fn2(Foo(3), 5))
}</lang> Run on the Go Playground.
Groovy
curry()
This method can be applied to any Groovy closure or method reference (demonstrated here with closures). The arguments given to the curry() method are applied to the original (invoking) method/closure. The "curry()" method returns a closure as it's result. The arguments on the "curry()" method are passed, in their specified order, as the first (left-most) arguments of the original method/closure. The remaining, as yet unspecified arguments of the original method/closure, form the argument list of the resulting closure.
Example: <lang groovy>def divide = { Number x, Number y ->
x / y
}
def partsOf120 = divide.curry(120)
println "120: half: ${partsOf120(2)}, third: ${partsOf120(3)}, quarter: ${partsOf120(4)}"</lang>
Results:
120: half: 60, third: 40, quarter: 30
rcurry()
This method can be applied to any Groovy closure or method reference. The arguments given to the rcurry() method are applied to the original (invoking) method/closure. The "rcurry()" method returns a closure as it's result. The arguments on the "rcurry()" method are passed, in their specified order, as the last (right-most) arguments of the original method/closure. The remaining, as yet unspecified arguments of the original method/closure, form the argument list of the resulting closure.
Example (using the same "divide()" closure as before): <lang groovy>def half = divide.rcurry(2) def third = divide.rcurry(3) def quarter = divide.rcurry(4)
println "30: half: ${half(30)}; third: ${third(30)}, quarter: ${quarter(30)}"</lang>
Results:
30: half: 15; third: 10, quarter: 7.5
History
I invite any expert on the history of the Groovy language to correct this if necessary. Groovy is a relatively recent language, with alphas and betas first appearing on the scene in 2003 and a 1.0 release in 2007. To the best of my understanding currying has been a part of the language from the outset.
Haskell
Likewise in Haskell, function type signatures show the currying-based structure of functions (note: "<lang haskell>\ -></lang>" is Haskell's syntax for anonymous functions, in which the sign <lang haskell>\</lang> has been chosen for its resemblance to the Greek letter λ (lambda); it is followed by a list of space-separated arguments, and the arrow <lang haskell>-></lang> separates the arguments list from the function body)
Prelude> let plus = \x y -> x + y Prelude> :type plus plus :: Integer -> Integer -> Integer Prelude> plus 3 5 8
and currying functions is trivial
Prelude> let plus5 = plus 5 Prelude> :type plus5 plus5 :: Integer -> Integer Prelude> plus5 3 8
In fact, the Haskell definition <lang haskell>\x y -> x + y</lang> is merely syntactic sugar for <lang haskell>\x -> \y -> x + y</lang>, which has exactly the same type signature:
Prelude> let nested_plus = \x -> \y -> x + y Prelude> :type nested_plus nested_plus :: Integer -> Integer -> Integer
Icon and Unicon
This version only works in Unicon because of the coexpression calling syntax used.
<lang unicon>procedure main(A)
add2 := addN(2)
write("add2(7) = ",add2(7))
write("add2(1) = ",add2(1))
end
procedure addN(n)
return makeProc{ repeat { (x := (x@&source)[1], x +:= n) } }
end
procedure makeProc(A)
return (@A[1], A[1])
end</lang>
- Output:
->curry add2(7) = 9 add2(1) = 3 ->
Io
A general currying function written in the Io programming language: <lang io>curry := method(fn, a := call evalArgs slice(1) block( b := a clone appendSeq(call evalArgs) performWithArgList("fn", b) ) )
// example: increment := curry( method(a,b,a+b), 1 ) increment call(5) // result => 6</lang>
J
Solution:Use & (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. Example:<lang j> threePlus=: 3&+
threePlus 7
10
halve =: %&2 NB. % means divide halve 20
10
someParabola =: _2 3 1 &p. NB. x^2 + 3x - 2</lang>
Note: The final example (someParabola) shows the single currying primitive (&) combined with J's array oriented nature, permits partial application of a function of any number of arguments.
Java
<lang java5> public class Currier<ARG1, ARG2, RET> {
public interface CurriableFunctor<ARG1, ARG2, RET> {
RET evaluate(ARG1 arg1, ARG2 arg2);
}
public interface CurriedFunctor<ARG2, RET> {
RET evaluate(ARG2 arg);
}
final CurriableFunctor<ARG1, ARG2, RET> functor;
public Currier(CurriableFunctor<ARG1, ARG2, RET> fn) { functor = fn; }
public CurriedFunctor<ARG2, RET> curry(final ARG1 arg1) {
return new CurriedFunctor<ARG2, RET>() {
public RET evaluate(ARG2 arg2) {
return functor.evaluate(arg1, arg2);
}
};
}
public static void main(String[] args) {
Currier.CurriableFunctor<Integer, Integer, Integer> add
= new Currier.CurriableFunctor<Integer, Integer, Integer>() {
public Integer evaluate(Integer arg1, Integer arg2) {
return new Integer(arg1.intValue() + arg2.intValue());
}
};
Currier<Integer, Integer, Integer> currier
= new Currier<Integer, Integer, Integer>(add);
Currier.CurriedFunctor<Integer, Integer> add5
= currier.curry(new Integer(5));
System.out.println(add5.evaluate(new Integer(2)));
}
}</lang>
JavaScript
<lang javascript> function addN(n) {
var curry = function(x) {
return x + n;
};
return curry;
}
add2 = addN(2); alert(add2); alert(add2(7));</lang>
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): <lang jq> def plus(x): . + x;
def plus5: plus(5); </lang>
We can now use plus5 as a filter, e.g.<lang jq>3 | plus5</lang> produces 8.
LFE
<lang lisp>(defun curry (f arg)
(lambda (x)
(apply f
(list arg x))))
</lang> Usage: <lang lisp> (funcall (curry #'+/2 10) 10) </lang>
Mathematica
Currying can be implemented by nesting the Function function. The following method curries the Plus function.
In[1]:= plusFC = Function[{x},Function[{y},Plus[x,y]]];
A higher currying function can be implemented straightforwardly.
In[2]:= curry = Function[{x}, Function[{y}, Function[{z}, x[y, z]]]];
- Output:
In[3]:= Plus[2,3]
Out[3]:= 5
In[4]:= plusFC[2][3]
Out[4]:= 5
In[5]:= curry[Plus][2][3]
Out[5]:= 5
Nemerle
Currying isn't built in to Nemerle, but is relatively straightforward to define. <lang Nemerle>using System; using System.Console;
module Curry {
Curry[T, U, R](f : T * U -> R) : T -> U -> R
{
fun (x) { fun (y) { f(x, y) } }
}
Main() : void
{
def f(x, y) { x + y }
def g = Curry(f); def h = Curry(f)(12); // partial application WriteLine($"$(Curry(f)(20)(22))"); WriteLine($"$(g(21)(21))"); WriteLine($"$(h(30))")
}
}</lang>
Nim
<lang nim>proc addN[T](n: T): auto = (proc(x: T): T = x + n)
let add2 = addN(2) echo add2(7)</lang> Alternative syntax: <lang nim>import future
proc addM[T](n: T): auto = (x: T) => x + n
let add3 = addM(3) echo add3(7)</lang>
OCaml
OCaml has a built-in natural method of defining functions that are curried: <lang ocaml>let addnums x y = x+y (* declare a curried function *)
let add1 = addnums 1 (* bind the first argument to get another function *)
add1 42 (* apply to actually compute a result, 43 *)</lang>
The type of addnums above will be int -> int -> int.
Note that fun addnums x y = ..., or, equivalently, let addnums = fun x y -> ..., is really just syntactic sugar for let addnums = function x -> function y -> ....
You can also define a general currying higher-ordered function: <lang ocaml>let curry f x y = f (x,y) (* Type signature: ('a * 'b -> 'c) -> 'a -> 'b -> 'c *)</lang> 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.
Oforth
Oforth can returns blocks and those blocks can be closures. Using blocks, it is possible to translate a function with multiple arguments into a function with less arguments.
Curring is possible, but it is not a built-in part of the language.
<lang Oforth>func: curry(f, n) { #[ n f perform ] }</lang>
Usage :
<lang Oforth>func: testCurring { | plus2 |
curry(#+, 2) ->plus2 10 plus2 perform println
}</lang>
PARI/GP
Simple currying example with closures. <lang parigp>curriedPlus(x)=y->x+y; curriedPlus(1)(2)</lang>
- Output:
3
Perl
This is a Perl 5 example of a general curry function and curried plus using closures: <lang perl>sub curry{
my ($func, @args) = @_;
sub {
#This @_ is later
&$func(@args, @_);
}
}
sub plusXY{
$_[0] + $_[1];
}
my $plusXOne = curry(\&plusXY, 1); print &$plusXOne(3), "\n";</lang>
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. <lang perl6>my &negative = &infix:<->.assuming(0); say negative 1;</lang>
- Output:
-1
PicoLisp
: (de multiplier (@X) (curry (@X) (N) (* @X N)) ) -> multiplier : (multiplier 7) -> ((N) (* 7 N)) : ((multiplier 7) 3) -> 21
Prolog
Works with SWI-Prolog and module lambda.pl
Module lambda.pl can be found at http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl .
?- [library('lambda.pl')].
% library(lambda.pl) compiled into lambda 0,00 sec, 28 clauses
true.
?- N = 5, F = \X^Y^(Y is X+N), maplist(F, [1,2,3], L).
N = 5,
F = \X^Y^ (Y is X+5),
L = [6,7,8].
Python
<lang python> def addN(n):
def adder(x):
return x + n
return adder</lang>
<lang python> >>> add2 = addN(2)
>>> add2 <function adder at 0x009F1E30> >>> add2(7) 9</lang>
Racket
The simplest way to make a curried functions is to use curry:
<lang racket>
- lang racket
(((curry +) 3) 2) ; =>5 </lang>
As an alternative, one can use the following syntax: <lang racket>
- lang racket
(define ((curried+ a) b)
(+ a b))
((curried+ 3) 2) ; => 5 </lang>
REXX
This example is modeled after the D example.
specific version
<lang ress>/*REXX program demonstrates a REXX currying method to perform addition. */ say 'add 2 to 3: ' add(2 ,3) say 'add 2 to 3 (curried):' add2(3) exit /*stick a fork in it, we're done.*/ /*──────────────────────────────────subroutines─────────────────────────*/ add: procedure; $=arg(1); do j=2 to arg(); $=$+arg(j); end; return $ add2: procedure; return add(arg(1), 2)</lang>
- Output:
add 2 to 3: 5 add 2 to 3 (curried): 5
generic version
<lang rexx>/*REXX program demonstrates a REXX currying method to perform addition. */ say 'add 2 to 3: ' add(2 ,3) say 'add 2 to 3 (curried):' add2(3) exit /*stick a fork in it, we're done.*/ /*──────────────────────────────────ADD subroutine──────────────────────*/ add: procedure; $=0; do j=1 for arg()
do k=1 for words(arg(j)); $=$+word(arg(j),k)
end /*k*/
end /*j*/
return $
/*──────────────────────────────────ADD2 subroutine─────────────────────*/
add2: procedure; return add(arg(1), 2)</lang>
output is the same as the 1st version.
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). <lang ruby> b = proc {|x, y, z| (x||0) + (y||0) + (z||0) } p b.curry[1][2][3] #=> 6 p b.curry[1, 2][3, 4] #=> 6 p b.curry(5)[1][2][3][4][5] #=> 6 p b.curry(5)[1, 2][3, 4][5] #=> 6 p b.curry(1)[1] #=> 1
b = proc {|x, y, z, *w| (x||0) + (y||0) + (z||0) + w.inject(0, &:+) } p b.curry[1][2][3] #=> 6 p b.curry[1, 2][3, 4] #=> 10 p b.curry(5)[1][2][3][4][5] #=> 15 p b.curry(5)[1, 2][3, 4][5] #=> 15 p b.curry(1)[1] #=> 1 </lang>
Scheme
This is a simple general currying function written in Scheme: <lang scheme>;curry:function,args->(function)
- Adding using currying
(define (curry f . args) (lambda x (apply f (append args x))))</lang> This is an example of applying a curried function: <lang scheme>>((curry + 10) 10) 20</lang>
Swift
<lang Swift>func addN(n:Int)(x:Int) -> Int { return x + n }
var add2 = addN(2) println(add2) // (Function) println(add2(x:7)) // 9</lang> There is a bug in Swift (as of 1.1) which forces the second parameter to always be labeled. To avoid it, you can return a closure (or nested function): <lang Swift>func addN(n:Int)->Int->Int { return {$0 + n} }
var add2 = addN(2) println(add2) // (Function) println(add2(7)) // 9</lang>
Standard ML
Standard ML has a built-in natural method of defining functions that are curried: <lang sml>fun addnums (x:int) y = x+y (* declare a curried function *)
val add1 = addnums 1 (* bind the first argument to get another function *)
add1 42 (* apply to actually compute a result, 43 *)</lang>
The type of addnums above will be int -> int -> int (the type constraint in the declaration only being necessary because of the polymorphic nature of the + operator).
Note that fun addnums x y = ... is really just syntactic sugar for val addnums = fn x => fn y => ....
You can also define a general currying higher-ordered function: <lang sml>fun curry f x y = f(x,y) (* Type signature: ('a * 'b -> 'c) -> 'a -> 'b -> 'c *)</lang> 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.
Tcl
The simplest way to do currying in Tcl is via an interpreter alias: <lang tcl>interp alias {} addone {} ::tcl::mathop::+ 1 puts [addone 6]; # => 7</lang> 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
The type of aliases used here are a simple restriction of general inter-interpreter aliases to the case where both the source and target interpreter are the current one; these aliases are a key component of the secure interpreter mechanism introduced in Tcl 7.6, and are the mechanism used to allow access to otherwise-insecure behavior from a secure context (e.g., to write to a particular file, but not any old file).
Wortel
The \ operator takes a function and an argument and partial applies the argument to the function. The &\ works like the \ operator but can also take an array literal and partial applies all the arguments in the array.
<lang wortel>@let {
addOne \+ 1 subtractFrom1 \- 1 subtract1 \~- 1 subtract1_2 &\- [. 1]
add ^+ ; partial apply to named functions addOne_2 \add 1
; testing [[ !addOne 5 ; returns 6 !subtractFrom1 5 ; returns -4 !subtract1 5 ; returns 4 !subtract1_2 5 ; returns 4 !addOne_2 5 ; returns 6 ]]
}</lang>
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. <lang zkl>addOne:= Op("+").fp(1); addOne(5) //-->6 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 f:=fcn(f,x){f(x)+x}.fp(fcn(x){x+1}); // above with lambdas all the way down</lang>