Higher-order functions: Difference between revisions

{{trans|Python}}

R function()

V result = first(second)

{{out}}

Code is called using the following macro, e.g. <code>PrintOutput #$FF,foo</code>. The printing routine is left unimplemented.

; input: desired function's input

; addr: function you wish to call

LDA \input

JSR doPrintOutput

; prints the output of the function "foo" to the screen.

; input:

JSR PrintAccumulator

=={{header|68000 Assembly}}==

This trivial example shows a simple return spoof.

JSR bar

foo:

=={{header|8th}}==

: pass-me

"I was passed\n" . ;

\ pass 'pass-me' to 'passer'

' pass-me passer

{{out}}

I was passed

=={{header|ActionScript}}==

public class MyClass {

}

}

=={{header|Ada}}==

===Simple Example===

procedure Subprogram_As_Argument is

begin

First(Second'Access);

===Complex Example===

procedure Subprogram_As_Argument_2 is

Int_Ptr := Complex_Func(F_Ptr, 3);

Put_Line(Integer'Image(Int_Ptr.All));

=={{header|Aime}}==

average(integer p, integer q)

{

return 0;

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

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

(

f(1) + 2

main: (

printf(($xg(5,2)l$,first(second)))

Output:

<pre>

=={{header|AmigaE}}==

The <tt>{}</tt> takes the pointer to an object (code/functions, variables and so on); Amiga E does not distinguish nor check anything, so it is up to the programmer to use the pointer properly. For this reason, a warning is always raised when a ''variable'' (<tt>func</tt>, holding a pointer to a real function in our case) is used like a function.

DEF s[10] : STRING

WriteF('\s\n', RealF(s,func(val),4))

compute({sin_wrap}, 0.0)

compute({cos_wrap}, 3.1415)

=={{header|AntLang}}==

=={{header|AppleScript}}==

-- with another handler (call).

on sing about topic by singer

end script

end hire

As we can see above, AppleScript functions (referred to as 'handlers' in Apple's documentation) are not, in themselves, first class objects. They can only be applied within other functions, when passed as arguments, if wrapped in Script objects. If we abstract out this lifting of functions into objects by writing an '''mReturn''' or '''mInject''' function, we can then use it to write some higher-order functions which directly accept unadorned AppleScript handlers as arguments.

We could, for example, write '''map''', '''fold/reduce''' and '''filter''' functions for AppleScript as follows:

-- PASSING FUNCTIONS AS ARGUMENTS TO

-- MAP, FOLD/REDUCE, AND FILTER, ACROSS A LIST

on isEven(x)

x mod 2 = 0

{{Out}}

{0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100},

===Alternative description===

In plain English, one handler can be passed as a parameter to another either in a script object …

on aHandler(aParameter)

say aParameter

end receivingHandler

… or directly, with the passed pointer being assigned to a script object property upon receipt:

say aParameter

end aHandler

end receivingHandler

It's not often that handlers actually need to be passed as parameters, but passing them in script objects is usually more flexible as additional information on which they depend can then be included if required which the receiving handler doesn't need to know.

=={{header|Arturo}}==

f x y

]

print [ "add:" doSthWith 2 3 $[x y][x+y] ]

{{out}}

<pre>add: 5

=={{header|ATS}}==

#include

"share/atspre_staload.hats"

//

} (* end of [main0] *)

=={{header|AutoHotkey}}==

f(x) {

return "This " . x

show("g") ; or just name the function

return

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

PRINT FNtwo(FNone(), 10, 11)

END

REM Function taking a function as an argument:

'''Output:'''

<pre>

A function's name in lowercase can be used to pass it as a subject, rather than a function to be executed.

[https://mlochbaum.github.io/BQN/try.html#code=VW5pcSDihpAg4o23CgrigKJTaG93IHVuaXEge/CdlY7wnZWpfSA14oC/NuKAvzfigL81 Try It!]

=={{header|Bracmat}}==

& ( print

= text a b func

. multiply

)

Output:

<pre>add(3,7)=10

=={{header|Brat}}==

doit = { f, a, b | f a, b }

=={{header|Burlesque}}==

The function "m[" (map) takes a block (a 'function') as it's argument. Add 5 to every element in a list (like map (+5) [1,2,3,4] in haskell):

blsq ) {1 2 3 4}{5.+}m[

{6 7 8 9}

=={{header|C}}==

Definition of a function whose only parameter is a pointer to a function with no parameters and no return value:

{

/* ... */

/* ... */

Note that you ''can't'' call the passed function by " *funcParameter() ", since that would mean "call funcParameter and then apply the * operator on the returned value".

Call:

/* ... */

'''Complex example'''

Definition of a function whose return value is a pointer to int and whose only parameter is a pointer to a function, whose (in turn) return value is a pointer to double and whose only parameter is a pointer to long.

{

long inLong;

/* ... */

Call:

/* ... */

int* outInt;

'''Pointer'''

Finally, declaration of a pointer variable of the proper type to hold such a function as myFunc:

/* ... */

Of course, in a real project you shouldn't write such a convoluted code, but use some typedef instead, in order to break complexity into steps.

This implementation works in all standard versions of C#.

// A delegate declaration. Because delegates are types, they can exist directly in namespaces.

Console.WriteLine("f=Div, f({0}, {1}) = {2}", a, b, Call(div, a, b));

}

===C# 2.0: Anonymous methods===

Anonymous methods were added in C# 2.0. Parameter types must be specified. Anonymous methods must be "coerced" to a delegate type known at compile-time; they cannot be used with a target type of Object or to initialize implicitly typed variables.

delegate int Func2(int a, int b);

Console.WriteLine("f=Div, f({0}, {1}) = {2}", a, b, Call(delegate(int x, int y) { return x / y; }, a, b));

}

==={{anchor|C#: Lambda expressions}}C# 3.0: Lambda expressions===

{{works with|C sharp|C#|3+}}

class Program

Console.WriteLine("f=Div, f({0}, {1}) = {2}", a, b, Call((x, y) => x / y, a, b));

}

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

{{works with|gcc|4.4}}

// Use <functional> for C++11

#include <tr1/functional>

first(second);

}

===Template and Inheritance===

{{works with|Visual C++|2005}}

#include <functional>

std::cout << first(second(), 2) << std::endl;

return 0;

=={{header|Clean}}==

Take a function as an argument and apply it to all elements in a list:

Pass a function as an argument:

Do the same using a anonymous function:

Do the same using currying:

=={{header|Clojure}}==

(defn append-hello [s]

(str "Hello " s))

(println (modify-string append-hello "World!"))

=={{header|CLU}}==

% type generator. The same works for iterators, using 'itertype'

do_calcs(1, 10, "Squares", square)

do_calcs(1, 10, "Cubes", cube)

{{out}}

<pre>Squares -> 1 4 9 16 25 36 49 64 81 100

Passing an anonymous function to built-in map/reduce functions:

Using a function stored in a variable:

sum = (a, b) -> a() + b()

sum(fn, fn) # => 16

List comprehension with a function argument:

smash = (ingredient) ->

contents = smash ingredient for ingredient in bowl

# => ["Smashed Cheese", "Smashed Tomato"]

Nested function passing:

triple = (x) -> x*3

addOne = (x) -> x+1

A function that returns a function that returns a function that returns a function that returns 2, immediately executed:

A function that takes a function that takes a function argument:

2 + x(-> 5)

)((y) -> y()+3)

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

In Common Lisp, functions are [[wp:First-class_object|first class objects]], so you can pass function objects as arguments to other functions:

ADD

CL-USER> (add 1 2)

CALL-IT

CL-USER> (call-it #'add 1 2)

The Common Lisp library makes extensive use of higher-order functions:

<pre>CL-USER> (funcall #'+ 1 2 3)

=={{header|Cowgol}}==

# In order to pass functions around, you must first define an interface.

end sub;

{{out}}

=={{header|D}}==

return f(a, b);

}

writeln("Add: ", hof(2, 3, (a, b) => a + b));

writeln("Multiply: ", hof(2, 3, (a, b) => a * b));

{{out}}

<pre>Add: 5

Multiply: 6</pre>

This longer and more systematic example shows D functions/delegates by passing each type of function/delegate to _test_ as argument.

// Test the function argument.

"Literal".test(function string() { return "literal.F"; })

.test(delegate string() { return "literal.D"; });

{{out}}}

<pre>Hi, Function : scope: Global (function) : immutable(char)[]()*

=={{header|DWScript}}==

function First(f : TFnType) : Float;

end;

=={{header|Dyalect}}==

{{trans|C#}}

f(a, b)

}

print("f=add, f(\(a), \(b)) = \(call((x, y) => x + y, a, b))")

print("f=mul, f(\(a), \(b)) = \(call((x, y) => x * y, a, b))")

{{out}}

=={{header|Déjà Vu}}==

]

for item in lst:

* 2

{{out}}

<pre>[ 2 4 10 ]</pre>

=={{header|Draco}}==

proc nonrec square(word n) word: n*n corp

proc nonrec cube(word n) word: n*n*n corp

do_func(1, 10, square);

do_func(1, 10, cube)

{{out}}

<pre> 1 4 9 16 25 36 49 64 81 100

1 8 27 64 125 216 343 512 729 1000</pre>

=={{header|E}}==

var out := []

for x in list {

? def foo(x) { return -(x.size()) }

> map(foo, ["", "a", "bc"])

=={{header|ECL}}==

INTEGER actionPrototype(INTEGER v1, INTEGER v2) := 0;

OUTPUT(doMany(2, applyValue4, applyValue2,multiValues));

=={{header|Efene}}==

F()

}

first(F2)

}

=={{header|Elena}}==

{{trans|Smalltalk}}

ELENA 4.1 :

public program()

var second := {"second"};

console.printLine(first(second))

{{out}}

<pre>second</pre>

=={{header|Elixir}}==

...(1)> def first(f), do: f.()

...(1)> def second, do: :hello

#Function<20.54118792/0 in :erl_eval.expr/5>

iex(5)> RC.first(f)

=={{header|Erlang}}==

Erlang functions are atoms, and they're considered different functions if their arity (the number of arguments they take) is different. As such, an Erlang function must be passed as <code>fun Function/Arity</code>, but can be used as any other variable:

-export([first/1, second/0]).

first(F) -> F().

Testing it:

{ok, tests}

2> tests:first(fun tests:second/0).

hello

3> tests:first(fun() -> anonymous_function end).

=={{header|ERRE}}==

ERRE function are limited to one-line FUNCTION, but you can write:

PROGRAM FUNC_PASS

PRINT(TWO(10,11))

END PROGRAM

Answer is 442

=={{header|Euler Math Toolbox}}==

>function f(x,a) := x^a-a^x

>function dof (f$:string,x) := f$(x,args());

[ -1 0 1 0 -7 ]

>plot2d("f",1,5;2):

=={{header|Euphoria}}==

print(1,call_func(fi,{a,b}))

end procedure

end function

=={{header|F Sharp|F#}}==

We define a function that takes another function f as an argument and applies that function twice to the argument x:

val twice : ('a -> 'a) -> 'a -> 'a

> twice System.Math.Sqrt 81.0;;

Another example, using an operator as a function:

=={{header|Factor}}==

Using words (factor's functions) :

IN: rosetacode

: argument-function1 ( -- ) "Hello World!" print ;

! Stack effect has to be written for runtime computed values :

: calling-function3 ( bool -- ) \ argument-function1 \ argument-function2 ? execute( -- ) ;

( scratchpad )

=={{header|FALSE}}==

Anonymous code blocks are the basis of FALSE control flow and function definition. These blocks may be passed on the stack as with any other parameter.

1 2 3 4 0 4[+]r;!." " { 10 }

1 2 3 4 1 4[*]r;!." " { 24 }

=={{header|Fantom}}==

class Main

{

}

}

=={{header|Forth}}==

Forth words can be referenced on the stack via their ''execution token'' or XT. An XT is obtained from a word via the quote operator, and invoked via '''EXECUTE'''. Anonymous functions may be defined via ''':NONAME''' (returning an XT) instead of a standard colon definition.

: cube dup dup * * ;

: map. ( xt addr len -- )

' square array 5 map. cr \ 1 4 9 16 25

' cube array 5 map. cr \ 1 8 27 64 125

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

use the EXTERNAL attribute to show the dummy argument is another function rather than a data object. i.e.

REAL, EXTERNAL :: FUNC1, FUNC2

REAL :: FUNC3

FUNC3 = FUNC1(x) * FUNC2(y)

Another way is to put the functions you want to pass in a module:

implicit none

contains

end subroutine asubroutine

=={{header|FreeBASIC}}==

Function square(n As Integer) As Integer

Print

Print "Press any key to quit"

{{out}}

The following defines an anonymous function and passes it to another function. In this case, the anonymous function is a comparison function that sorts by string length.

cmpFunc = {|a,b| length[a] <=> length[b]}

a = ["tree", "apple", "bee", "monkey", "z"]

sort[a, cmpFunc]

You can also look up functions by name and number of arguments. The following is equivalent to the previous example.

lengthCompare[a,b] := length[a] <=> length[b]

a = ["tree", "apple", "bee", "monkey", "z"]

sort[a, func]

=={{header|FutureBasic}}==

dim as pointer functionOneAddress

print fn FunctionTwo( 12, 12 )

Output:

=={{header|GAP}}==

return f(x);

end;

Eval(x -> x^3, 7);

=={{header|Go}}==

import "fmt"

func func1(f func(string) string) string { return f("a string") }

func func2(s string) string { return "func2 called with " + s }

=={{header|Groovy}}==

As [[closures]]:

second = { println "second" }

As functions:

def second() { println "second" }

=={{header|Haskell}}==

A function is just a value that wants arguments:

func2 s = "func2 called with " ++ s

Or, with an anonymous function:

main = print $ func (\x y -> x+y)

Note that <tt>func (\x y -> x+y)</tt> is equivalent to <tt>func (+)</tt>. (Operators are functions too.)

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

local lst

lst := [10, 20, 30, 40]

procedure callback(arg)

write("->", arg)

=={{header|Inform 6}}==

As in C, functions in Inform 6 are not first-class, but pointers to functions can be used.

print "Hello^";

];

[ Main;

call_func(func);

=={{header|Inform 7}}==

Phrases usually aren't defined with names, only with invocation syntax. A phrase must be given a name (here, "addition" and "multiplication") in order to be passed as a phrase value.

To decide which number is (N - number) added to (M - number) (this is addition):

demonstrate addition as "Add";

demonstrate multiplication as "Mul";

=={{header|J}}==

''Adverbs'' take a single verb or noun argument and ''conjunctions'' take two. For example,<tt> / </tt>(insert)<tt> \ </tt>(prefix) and<tt> \. </tt>(suffix) are adverbs and <tt> @ </tt>(atop), <tt> & </tt>(bond or compose) and <tt> ^: </tt>(power) are conjunctions. The following expressions illustrate their workings.

23

>./ 3 1 4 1 5 9 NB. max

1 1.5 1.41667 1.41422 1.41421

f^:(i.5) 1x NB. rational approximations to sqrt 2

Adverbs and conjunctions may also be user defined

+

+ conjunction def 'v' -

110

^ conjunction def '10 v 2 u y' * 11

=={{header|Java}}==

There is no real callback in Java like in C or C++, but we can do the same as swing does for executing an event. We need to create an interface that has the method we want to call or create one that will call the method we want to call. The following example uses the second way.

public NewClass() {

interface AnEventOrCallback {

public void call();

From Java 8, lambda expressions may be used. Example (from Oracle):

public static void main(String[] args) {

JButton testButton = new JButton("Test Button");

frame.setVisible(true);

}

=={{header|JavaScript}}==

return func();

}

var result = first(second);

An example with anonymous functions and uses in the core library

{{works with|Firefox|1.5}} for methods <code>filter</code> and <code>map</code>.

>>> array

[2, 4, 5, 13, 18, 24, 34, 97]

// sort the array from largest to smallest

>>> array.sort(function (a, b) { return a < b });

=={{header|Joy}}==

This example is taken from V.

Define first as multiplying two numbers on the stack.

There will be a warning about overwriting builtin first.

Define second as interpreting the passed quotation on the stack.

Pass first enclosed in quotes to second.

The program prints 6.

====Example 1: "hello blue world"====

("world" | filter) as $str

| "hello \($str)" ;

foo( blue ) # prints "hello blue world"

====Example 2: g(add; 2; 3)====

def g(f; x; y): [x,y] | f;

====Example: Built-in higher-order functions====

In the following sequence of interactions, we pass the function *is_even/0* to some built-in higher order functions. *is_even/0* is defined as follows:

if floor == . then (. % 2) == 0

else error("is_even expects its input to be an integer")

# Are all integers between 1 and 5 even?

# For this example, we will use all/2 even

false

true

=={{header|Julia}}==

function foo(x)

str = x("world")

end

foo(y -> "blue $y") # prints "hello blue world"

The above code snippet defines a named function, <tt>foo</tt>, which takes a single argument, which is a <tt>Function</tt>.

In the final line, <tt>foo</tt> is called with an anonymous function that takes a string, and returns a that string with <tt>"blue "</tt> preppended to it.

function g(x,y,z)

x(y,z)

end

println(g(+,2,3)) # prints 5

This code snippet defines a named function <tt>g</tt> that takes three arguments: <tt>x</tt> is a function to call, and <tt>y</tt> and <tt>z</tt> are the values to call <tt>x</tt> on.

In the following interactive session, we pass the function iseven to a few higher order functions. The function iseven returns true if its argument is an even integer, false if it is an odd integer, and throws an error otherwise. The second argument to the functions is a range of integers, specifically the five integers between 1 and 5 included.

false

true

false

=={{header|Klingphix}}==

:*2 * 2 * ;

8 4 @*2 apply print nl

=={{header|Kotlin}}==

Kotlin is a functional language. Example showing how the builtin map function is used to get the average value of a transformed list of numbers:

val list = listOf(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)

val a = list.map({ x -> x + 2 }).average()

val g = list.map({ x -> x * x * x }).average()

println("A = %f G = %f H = %f".format(a, g, h))

Another example showing the syntactic sugar available to Kotlin developers which allows them to put the lambda expression out of the parenthesis whenever the function is the last argument of the higher order function. Notice the usage of the inline modifier, which inlines the bytecode of the argument function on the callsite, reducing the object creation overhead (an optimization for pre Java 8 JVM environments, like Android) (translation from Scala example):

fun main(args: Array<String>) {

val result = higherOrderFunction(3, 5) { x, y -> x + y }

println(result)

{{out}}

=={{header|Lambdatalk}}==

{def add

{lambda {:f :g :x}

{S.reduce + {S.serie 1 10}}

-> 55

=={{header|Lily}}==

{

return x * x

# Calling user-defined transformation.

=={{header|Lingo}}==

Lingo doesn't support first-class functions. But functions can be passed as "symbols", and then be called via Lingo's 'call' command. Global functions - i.e. either built-in functions or user-defined functions in movie scripts - are always methods of the core '_movie' object, for other object functions (methods) also the object has to be specified. Here as example an implementation of a generic "map" function:

----------------------------------------

-- Runs provided function (of some object) on all elements of the provided list, returns results as new list

end repeat

return res

-- passes the built-in function 'sin' (which is a method of the _movie object) as argument to map

put res

=={{header|Logo}}==

You can pass the quoted symbol for the function and invoke it with RUN.

print "stuff

end

end

runstuff "printstuff ; stuff

=={{header|Lua}}==

Lua functions are first-class:

b = function(r) print( r() ) end

=={{header|Luck}}==

Higher-order functions can be used to implement conditional expressions:

function lambda_false(x: 'a)(y: 'a): 'a = y;;

function lambda_if(c:'a -> 'a -> 'a )(t: 'a)(f: 'a): 'a = c(t)(f);;

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

We can pass by reference a standard function, or we can pass by value a lambda function (also we can pass by reference as reference to lambda function)

Function Foo (x) {

=x**2

Print Bar(&K.MulZ(), 20)=200

Print K.Z=11

Example using lambda function

Foo = Lambda k=1 (x)-> {

k+=2

Print Bar2(&NewFoo, 20)=409

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

Passing 3 arguments and a value (could be a number, variable, graphic or a function as well, actually it could be ''anything''), and composing them in an unusual way:

PassFunc[Tan, Cos, Sin, x]

% /. x -> 0.12

gives back:

0.119414

=={{header|MATLAB}} / {{header|Octave}}==

F2=@cos; % F2 refers to function cos()

F4 = 'cos';

feval(F3,pi/4)

=={{header|Maxima}}==

caller(f, n) := sum(f(i), i, 1, n)$

caller(callee, 3);

"called with 1"

"called with 2"

=={{header|MAXScript}}==

(

print "Second"

)

=={{header|Metafont}}==