Higher-order functions: Difference between revisions

{{trans|Python}}

 

R function()

 

 

V result = first(second)

 

{{out}}

second

</pre>

 

=={{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>

441

</pre>

 

=={{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|CoffeeScript}}==

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|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}}

public program()

{

var first := (f => f());

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|Fōrmulæ}}==

 

 

 

 

=={{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.

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}}==

We can simulate this by using <code>scantokens</code>, which ''digests'' a string as if it would be a source input.

 

 

t := calcit(100.4, "sind");

show t;

 

=={{header|МК-61/52}}==

П7 КПП7 В/О

 

''Note'': as the receiver of argument used register ''Р7''; the result is "1" on the indicator.

 

=={{header|Modula-3}}==

 

IMPORT IO;

BEGIN

First(Second);

 

=={{header|Morfa}}==

{{trans|D}}

func g(a: int, b: int, f: func(int,int): int): int

{

println("Multiply: ", g(2, 3, func(a: int, b: int) { return a * b; }));

}

 

=={{header|Nanoquery}}==

{{trans|Python}}

return function()

end

 

result = first(second)

{{out}}

<pre>second</pre>

=={{header|Nemerle}}==

Functions must declare the types of their parameters in Nemerle. Function types in Nemerle are written ''params type'' -> ''return type'', as seen in the simple example below.

 

=={{header|NewLISP}}==

(lambda (a b) (* a b))

> (define (call-it f x y) (f x y))

> (call-it my-multiply 2 3)

6

 

=={{header|Nim}}==

return fn()

 

return "second"

 

 

=={{header|Oberon-2}}==

Works with oo2c version 2

MODULE HOFuns;

IMPORT

PrintWords(words,Tools.AdjustRight)

END HOFuns.

 

=={{header|Objeck}}==

bundle Default {

class HighOrder {

}

}

 

=={{header|OCaml}}==

 

A function is just a value that wants arguments:

val func1 : (string -> 'a) -> 'a = <fun>

# let func2 s = "func2 called with " ^ s;;

# print_endline (func1 func2);;

func2 called with a string

 

Or, with an anonymous function:

val func : (int -> int -> 'a) -> 'a = <fun>

 

# Printf.printf "%d\n" (func (fun x y -> x + y));;

3

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

 

We can pass a function handle (<code>@function_name</code>)

 

r = f(g(v));

endfunction

 

computeit(@exp, @sin, pi/3)

 

Or pass the string name of the function and use the <code>feval</code> primitive.

 

r = f(feval(g, v));

endfunction

 

 

=={{header|Oforth}}==

If you add # before a function or method name you push the function object on the stack (instead of performing the function). This allows to pass functions to other functions, as for any other object.

Here we pass #1+ to map :

 

=={{header|Ol}}==

; typical use:

(for-each display '(1 2 "ss" '(3 4) 8))

(do print 12345)

; ==> 12345

 

=={{header|ooRexx}}==

routines are first class ooRexx objects that can be passed to other routines or methods and invoked.

say callit(.routines~fact, 6)

say callit(.routines~square, 13)

next = current

end

{{out}}

<pre>55

Functions in Order can accept any other named function, local variable, or anonymous function as arguments:

 

#include <order/interpreter.h>

 

)

// -> 16

 

The only difference between toplevel function definitions, and variables or literals, is that variables and anonymous functions must be called using the <code>8ap</code> syntactic form rather than direct argument application syntax. This is a limitation of the C preprocessor.

 

=={{header|OxygenBasic}}==

'FUNCTION TO BE PASSED

'=====================

print g(@f#double#double) 'result '42'

 

 

=={{header|Oz}}==

Functions are just regular values in Oz.

fun {Twice Function X}

{Function {Function X}}

end

in

 

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

{{works with|PARI/GP|2.4.2 and above}} <!-- requires closures -->

e = eps() * 2;

aval=ff(a);

precision(2. >> (32 * ceil(default(realprecision) * 38539962 / 371253907)), 9)

};

 

=={{header|Pascal}}==

Standard Pascal (will not work with Turbo Pascal):

 

function first(function f(x: real): real): real;

begin

writeln(first(second));

 

[[Turbo Pascal]] (will not work with Standard Pascal):

 

 

type

begin

writeln(first(second));

 

=== using FreePascal : Higher-order function MAP / REDUCE ( FOLDL / FOLDR ) / FILTER ===

UNIT MRF;

{$mode Delphi} {$H+} {$J-} {$R+} (*) https://www.freepascal.org/docs-html/prog/progch1.html (*)

It contains a text IDE called fp

 

 

(*)

 

 

 

Output:

 

=={{header|Perl}}==

# take a function and a value

my $func = shift;

);

 

 

my ($sub, @ret) = @_; # this function applies a function that is expected to modify $_ to a list

$sub->() for @ret; # it allows for simple inline application of the s/// and tr/// constructs

 

print join ", " => apply {tr/aeiou/AEIOU/} qw/one two three four/;

 

 

sub second {'second'}

print first \&second;

 

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">procedure</span> <span style="color: #000000;">use</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">fi</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">fi</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">use</span><span style="color: #0000FF;">(</span><span style="color: #000000;">add</span><span style="color: #0000FF;">,</span><span style="color: #000000;">23</span><span style="color: #0000FF;">,</span><span style="color: #000000;">45</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

The plain add, without a trailing '(' to make it a direct invocation, resolves to a symbol table index.<br>

Obviously you can use (an otherwise pointless) user defined type (of any name you like) instead of integer if preferred, eg

<span style="color: #008080;">type</span> <span style="color: #000000;">rid</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000080;font-style:italic;">/*r*/</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #004600;">true</span> <span style="color: #008080;">end</span> <span style="color: #008080;">type</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">use</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rid</span> <span style="color: #000000;">fi</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">)...</span>

 

=={{header|Phixmonti}}==

 

def apply exec enddef

 

23 45 getid suma apply print

 

=={{header|PHP}}==

return $func();

}

}

 

Or, with an anonymous function in PHP 5.3+:

return $func();

}

 

 

=={{header|PicoLisp}}==

(Fun) )

-> first

 

: (mapcar add (1 2 3) (4 5 6))

 

=={{header|PL/I}}==

f: procedure (g) returns (float);

declare g entry (float);

 

x = f(p); /* where "p" is the name of a function. */

 

=={{header|Pop11}}==

define x_times_three_minus_1(x);

return(3*x-1);

 

;;; Pass it as argument to built-in function map and print the result

 

=={{header|PostScript}}==

Postscript functions are either built-in operators or executable arrays (procedures). Both can take either as arguments.

% operator example

% 'ifelse' is passed a boolean and two procedures

/bar { (Hello, world!) } def

/bar load foo ==

 

=={{header|PowerShell}}==

{{works with|PowerShell|4.0}}

function f ($y) {

$y*$y

(f $y)

}

 

You can implement a function inside a function.

 

function g2($y) {

function f2($y) {

(f2 $y)

}

<b>Calling:</b>

g f 5

g2 9

<b>Output:</b>

<pre>

 

=={{header|Prolog}}==

first(Predicate) :- call(Predicate).

second(Argument) :- write(Argument).

 

:-first(second('Hello World!')).

 

=={{header|PureBasic}}==

 

Procedure NumberTwo(arg$)

EndProcedure

 

 

=={{header|Python}}==

{{works with|Python|2.5}}

 

return function()

 

return "second"

 

 

or

 

 

Functions are first class objects in Python. They can be bound to names ("assigned" to "variables"), associated with keys in dictionaries, and passed around like any other object.

Its helpful to remember that in Q, when parameters aren't named in the function declaration, <tt>x</tt> is assumed to be the first parameter.

 

q)sayHi:{-1"Hello ",x;}

q)callFuncWithParam:{x["Peter"]}

Hello Peter

q)callFuncWithParam[sayHi]

 

=={{header|Quackery}}==

 

 

 

 

...

 

...

 

...

Stack empty.

 

=={{header|R}}==

tf <- function(x) x^pi # a func. just to test

 

print(f(sin))

print(f(cos))

 

=={{header|Racket}}==

#lang racket/base

(define (add f g x)

(+ (f x) (g x)))

(add sin cos 10)

 

=={{header|Raku}}==

either a bare block, or a parametrized block introduced with <tt>-></tt>, which serves as a "lambda":

 

todo(); todo(); # declaring &todo also defines bare function

}

# output:

# 1: Hello!

 

=={{header|Raven}}==

This is not strictly passing a function, but the string representing the function name.

"doit called with " print $v1 print "\n" print

 

$v2 call

 

{{out}}

<pre>callit called with doit

 

=={{header|REBOL}}==

Title: "Function Argument"

URL: http://rosettacode.org/wiki/Function_as_an_Argument

print ["Squared:" mold map :square x]

print ["Cubed: " mold map :cube x]

 

Output:

 

=={{header|Retro}}==

 

#31 [ (n-n) #100 * ] disp

 

=={{header|REXX}}==

call function 'fact' , 6; say right( 'fact{'$"} = ", 30) result

call function 'square' , 13; say right( 'square{'$"} = ", 30) result

function: arg ?.; parse arg ,$; signal value (?.)

reverse: return 'REVERSE'($)

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

<pre>

 

=={{header|Ring}}==

# Project : Higher-order functions

 

next

see nl

Output:

<pre>

=={{header|Ruby}}==

With a proc (procedure):

def to2(&f)

f[2]

 

to2(&succ) #=> 3

With a method:

n+1

end

 

meth = method(:succ)

 

=={{header|Rust}}==

Functions are first class values and identified in the type system by implementing the FnOnce, FnMut or the Fn trait which happens implicitly for functions and closures.

f(10)

}

println!("{}", execute_with_10(|n| n*n )); // closure

println!("{}", execute_with_10(square)); // function

{{out}}

<pre>100

 

=={{header|Scala}}==

Call:

 

=={{header|Scheme}}==

 

A function is just a value that wants arguments:

> (define (func2 s) (string-append "func2 called with " s))

> (begin (display (func1 func2)) (newline))

 

Or, with an anonymous function:

> (begin (display (func (lambda (x y) (+ x y)))) (newline))

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

 

=={{header|SenseTalk}}==

put () into newlist

repeat with each item of oldlist

end repeat

return newlist

 

put Map(fruits, Uppercase)

 

=={{header|Sidef}}==

return f();

}

 

say first(second); # => "second"

 

=={{header|Slate}}==

Methods and blocks can both be passed as arguments to functions (other methods and blocks):

 

=={{header|Smalltalk}}==

 

second := [ 'second' ].

 

=={{header|Sparkling}}==

return func(arg);

}

 

let answer = call_me(function(x) { return 6 * x; }, 7);

 

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

 

val func1 = fn : (string -> 'a) -> 'a

- fun func2 s = "func2 called with " ^ s;

- print (func1 func2 ^ "\n");

func2 called with a string

 

Or, with an anonymous function:

val func = fn : (int * int -> 'a) -> 'a

 

- print (Int.toString (func (fn (x, y) => x + y)) ^ "\n");

3

Note that <tt>func (fn (x, y) => x + y)</tt> is equivalent to <tt>func op+</tt>. (Operators are functions too.)

 

=={{header|SuperCollider}}==

 

=={{header|Swift}}==

func func2(s: String) -> String { return "func2 called with " + s }

 

Or, with an anonymous function:

Note that <tt>{(x, y) in x + y}</tt> can also be written as <tt>{$0 + $1}</tt> or just <tt>+</tt>.

 

=={{header|Tcl}}==

proc demo {function} {

$function

}

# for example:

It is more common to pass not just a function, but a command fragment or entire script. When used with the built-in <tt>list</tt> command (which introduces a very useful degree of quoting) this makes for a very common set of techniques when doing advanced Tcl programming.

proc demoFrag {fragment} {

{*}$fragment 2

demoScript {

parray tcl_platform

 

=={{header|TI-89 BASIC}}==

The function name passed cannot be that of a local function, because the local function <code>map</code> does not see the local variables of the enclosing function.

 

Define map(f,l)=Func

Return seq(#f(l[i]),i,1,dim(l))

EndFunc

 

=={{header|Toka}}==

Toka allows obtaining a function pointer via the '''`''' (''backtick'') word. The pointers are passed on the stack, just like all other data.

 

[ invoke ] is second

 

=={{header|Trith}}==

Due to the homoiconic program representation and the [[concatenative]] nature of the language, higher-order functions are as simple as:

: hello "Hello, world!" print ;

 

=={{header|TXR}}==

<code>lambda</code> passed to <code>mapcar</code> with environment capture:

 

(mapcar (lambda (x y) (list (inc counter) x y))

'(a b c) '(t r s))))

@ (rep)@a:@(last)@a@(end)

@ (end)

 

<pre>1:a:t

3:c:s</pre>

 

=={{header|Ursa}}==

{{trans|Python}}

Functions are first-class objects in Ursa.

return (f)

end

 

out (first second) endl console

 

=={{header|Ursala}}==

equivalent to the given functon composed with itself.

 

test program:

#cast %e

 

output:

<pre>2.000000e+00</pre>

=={{header|V}}==

Define first as multiplying two numbers on stack

Define second as applying the passed quote on stack

Pass the first enclosed in quote to second which applies it on stack.

=6

 

=={{header|VBA}}==

Based on the Pascal solution

Dim result As Single

result = first("second")

Function second(x As Single) As Single

second = x / 2

 

=={{header|Visual Basic .NET}}==

===Named methods===

{{trans|C#: Named methods}}

Delegate Function Func2(a As Integer, b As Integer) As Integer

 

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

End Sub

 

===Lambda expressions===

{{trans|C#: Lambda expressions}}

Lambda expressions in VB.NET are similar to those in C#, except they can also explicitly specify a return type and exist as standalone "anonymous delegates". An anonymous delegate is created when a lambda expression is assigned to an implicitly typed variable (in which case the variable receives the type of the anonymous delegate) or when the target type given by context (at compile-time) is MulticastDelegate, Delegate, or Object. Anonymous delegates are derived from MulticastDelegate and are implicitly convertible to all compatible delegate types. A formal definition of delegate compatibility can be found in the language specification.

' Uses the System generic delegate; see C# entry for details.

Function [Call](f As Func(Of Integer, Integer, Integer), a As Integer, b As Integer) As Integer

Console.WriteLine("f=Div, f({0}, {1}) = {2}", a, b, [Call](anon, a, b))

End Sub

 

=={{header|Visual Prolog}}==

 

domains

intFunction = (integer In) -> integer Out procedure (i).

write(dotwice(addone,2)),

succeed().

 

=={{header|Wren}}==

System.print("first function called")

f.call()

var second = Fn.new { System.print("second function called") }

 

 

{{out}}

second function called

</pre>

 

 

=={{header|zkl}}==

Everything is a first class object so

{{out}}

<pre>

</pre>

or

 

=={{header|ZX Spectrum Basic}}==

{{trans|BBC_BASIC}}

Input "FN " token first, then enclose it in double quotation marks.

20 DEF FN n(x,y)=(x+y)^2

 

{{omit from|GUISS}}