Call a function: Difference between revisions

[[Category:Simple]]

 

;Task:

This task is ''not'' about [[Function definition|defining functions]].

<br><bR>

=={{header|11l}}==

{{trans|Python}}

 

// call

no_args()

opt_args() // 1

opt_args(3.141) // 3.141</syntaxhighlight>

=={{header|360 Assembly}}==

Due to assembler, argument are passed by reference.<br>

With:

Y DS F

Z DS F</syntaxhighlight>

If you do not want to use the CALL macro instruction and for a link-edited object-module:

LA R1,PARMLIST address of the paramter list

BALR R14,R15 branch and link

DC A(Y)</syntaxhighlight>

If you call a link-edited object-module:

ST R0,Z Z=MULTPLIC(X,Y)</syntaxhighlight>

If you call an load-module at execution time:

LR R15,R0 retrieve entry address

CALL (R15),(X,Y) call MULTPLIC(X,Y)

ST R0,Z Z=MULTPLIC(X,Y)</syntaxhighlight>

=={{header|6502 Assembly}}==

 

To call a function, you use <code>JSR</code> followed by the pointer to its beginning. Most of the time this will be a labeled line of code that your assembler will convert to an actual memory address for you during the assembly process.

 

 

Function arguments are often passed in through registers, the zero page, or the stack. Given how awkward it is to work with the stack on the 6502, it's best not to use the hardware stack as a means of parameter passing. CC65 uses a software stack in the upper half of zero page, which is indexed using the X register.

;adds the values in zero page address $00 and $01, outputs to accumulator.

LDA $00 ;load the byte stored at memory address $0000

 

The closest thing 6502 has to true "built-in functions" are the interrupt vectors whose pointers are stored at the very end of memory. They are, in order: Non-maskable interrupt (NMI), reset, and IRQ (Interrupt Request). They are no different than other functions except they end in <code>RTI</code> rather than <code>RTS</code>. With "bare-metal programming" like on the NES this is all you have, but most computers of the 80s had some sort of kernel or operating system that had pre-defined functions you could use simply by <code>JSR</code>ing their memory address. The actual memory locations of these, and what they did, varies by implementation.

=={{header|8086 Assembly}}==

 

A function that requires no arguments is simply <code>CALL</code>ed:

 

Functions with a fixed number of arguments have their arguments pushed onto the stack prior to the call. This is how C compilers generate 8086 assembly code. Assembly written by a person can use the stack or registers to pass arguments. Passing via registers is faster but more prone to errors and clobbering, which can cause other functions to not operate correctly.

 

push bx ;first argument - typically arguments are pushed in the reverse order they are listed.

call foo

The 8086 cannot support named arguments directly. However it is possible to label a section of RAM, and use that as the argument for a function.

 

ld ax,word ptr[ds:bar] ;load from bar, which is a 16 bit storage location in the data segment (DS), into AX</syntaxhighlight>

 

Built-in functions are typically called using the <code>INT</code> instruction. This instruction takes a numeric constant as its primary argument, and the value in <code>AH</code> as a selector of sorts. This command is used to exit a program and return to MS-DOS:

mov AL,00h

int 21h</syntaxhighlight>

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program callfonct.s */

Resultat : -90

</pre>

=={{header|ActionScript}}==

 

myfunction(6,b); // function with two arguments in statement context

stringit("apples"); //function with a string argument</syntaxhighlight>

=={{header|Ada}}==

 

* There are no differences between calling built-in vs. user defined functions.

 

 

...

A : Integer := F(12);

* If the number of parameters of F were fixed to two (by omitting the ":= 0" in the specification), then B and C would be OK, but A wouldn't.

 

function Sum(A: Integer_Array) return Integer is

S: Integer := 0;

B := Sum((1,2,3,4)); -- B = 10</syntaxhighlight>

 

Fun: not null access function (X: Integer; Y: Integer)

return Integer);

-- taking two Integers and returning an Integer.</syntaxhighlight>

 

Named := H(Int => A, Fun => F'Access);

Mixed := H(A, Fun=>F'Access); </syntaxhighlight>

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

# A function called without arguments: #

f;

See [http://rosettacode.org/wiki/Optional_parameters#ALGOL_68 Optional Parameters] for an example of optional parameters in Algol 68.<br>

See [http://rosettacode.org/wiki/Named_parameters#ALGOL_68 Named Parameters] for an example of named parameters in Algol 68.

=={{header|ALGOL W}}==

% calling a function with no parameters: %

f;

 

% Partial application is not possible in Algol W %</syntaxhighlight>

=={{header|AntLang}}==

AntLang provides two ways to apply a function.

One way is infix application.

Infix application is right associative, so x f y g z means x f (y g z) and not (x f y) g z.

You can break this rule using parenthesis.

The other way is prefix application.

echo["Hello!"]

time[]</syntaxhighlight>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

 

</syntaxhighlight>

=={{header|Arturo}}==

print "Hello World!"

]

yep, it worked

3</pre>

=={{header|AutoHotkey}}==

f()

 

; Partial application is impossible.

</syntaxhighlight>

=={{header|AWK}}==

 

The awk interpreter reads the entire script prior to processing, so functions can be called from sections of code appearing before the definition.

 

sayhello() # Call a function with no parameters in statement context

b=squareit(3) # Obtain the return value from a function with a single parameter in first class context

 

The awk extraction and reporting language does not support the use of named parameters.

=={{header|Axe}}==

In Axe, up to six arguments are passed as the variables r₁ through r₆. As with all variables in Axe, these exist in the global scope, which makes nested function calls and recursion quite difficult.

ARGS(1,5,42)</syntaxhighlight>

 

Since arguments are simply global variables, they are always optional and can be omitted from right to left.

OPARG(1,2,3)

OPARG()</syntaxhighlight>

 

Somewhat similar to [[TI-83 BASIC]], the last evaluated expression becomes the return value of the function. However, this is distinct from the Ans variable. Return values can be captured just like any other expression.

Disp GETSTR()</syntaxhighlight>

 

User-defined functions can be distinguished from language-defined functions by the fact that language-defined function names are composed of atomic tokens (usually with built-in parentheses) whereas user-defined function names are composed of individual characters. Also, because only uppercase letters are available by default in the OS, most user-defined names are all uppercase while language-defined names are mixed case.

axeFunc()</syntaxhighlight>

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

nuevaCadena$ = ""

 

Igual que la entrada de FreeBASIC.

</pre>

=={{header|Batch File}}==

 

Batch files do not have a traditional "function" system like OOP languages, however this is the closest thing to it. The only difference between a block of code and a function is the way method you choose to invoke it. It's also worth noting that all batch files can be called from any other batch file, performing a function. A function should be put somewhere in the code where it will not be parsed unless the script is redirected there.

 

:: http://rosettacode.org/wiki/Call_a_function

:: Demonstrate the different syntax and semantics provided for calling a function.

C:\Test Directory\test.file

</pre>

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

BBC BASIC distinguishes between functions (which return one value), procedures (which may return an arbitrary number of values including zero), and subroutines. Functions can be built-in or user-defined.

A call to a <b>built-in function</b> (for example, the square root function) is an expression:

The parentheses can often be omitted:

The name of a <b>user-defined function</b> must begin with <tt>FN</tt>. A call to it is also an expression:

(The sigils <tt>$</tt> and <tt>%</tt> identify the variables' types.)

A function that takes no arguments can be called omitting the parentheses:

The name of a <b>procedure</b> must begin with <tt>PROC</tt>. A call to it is a statement, not an expression:

If it has arguments, they come in parentheses just as with a function:

Note that you <i>cannot tell from this syntax</i> which of the variables <tt>bar$</tt>, <tt>baz%</tt>, and <tt>quux</tt> are arguments provided to the procedure and which of them are return values from it. You have to look at where it is defined:

<b>Subroutines</b> are provided for compatibility with older, unstructured dialects of BASIC; otherwise they are never really used. They require statements to be numbered, and they can neither receive arguments nor return values: they can only manipulate global variables. The <tt>GOSUB</tt> and <tt>RETURN</tt> statements in fact mirror assembly language 'jump to subroutine' and 'return from subroutine' instructions quite closely.

=={{header|BQN}}==

 

'''Calling a function that requires no arguments:''' BQN does not have zero argument functions. Having a function that does so is done with the help of a dummy argument, like so:

 

 

The dot symbol <code>·</code> indicates that the argument is nothing, and hence is discarded. Hence, the zero provided to it is discarded, and 1 + 1 = 2 is returned.

'''Calling a function with a fixed number of arguments:''' BQN functions always take 1 or two arguments, and their names must always start with a capital letter. A function is called like a primitive function, by writing its name or the function itself between the arguments. For example, given a function named <code>F</code>:

 

 

 

'''Calling a function with optional arguments:''' optional arguments are not supported by BQN.

'''Calling a function with named arguments:''' BQN has block headers, which destructure an input array into given variables using pattern matching. These can then be referenced later by the names given.

 

𝕊 one‿two‿three:

one∾two∾three

'''Using a function in statement context:''' BQN user defined functions have the same syntactic roles as primitive functions in an expression, so they can be used like any primitive.

 

is the same as

 

'''Using a function in first-class context within an expression:''' BQN supports lisp-style functional programming, and hence supports first class usage of functions.

 

is an example of a list of functions, which can later be called with the help of a higher order function.

 

'''Obtaining the return value of a function:''' A block function will always return the value of the last statement within it. To obtain the return value of a function, you can assign it to a variable, or modify an existing variable with the return value.

 

 

Arguments are passed to BQN functions by value only.

'''Partial Application:''' BQN has two combinators for this purpose. Before (<code>⊸</code>) returns a function with a constant left argument, and After (<code>⟜</code>) returns a function with a constant right argument.

 

=={{header|Bracmat}}==

 

Strictly speaking, all Bracmat functions receive at least one argument. But empty strings are valid expressions, so you can do

 

or

 

Both function calls pass the right and side of the <code>$</code> or <code>'</code> operator. This is in fact still something: an empty string.

 

You can do

The <code>;</code> marks the end of a Bracmat statement.

 

(Copied from JavaScript:) Bracmat functions are first-class citizens; they can be stored in variables and passed as arguments. Assigning to a variable <code>yourfunc</code> can be done in a few ways. The most common one is

 

If there is already a function <code>myfunc</code> that you want to assign to <code>yourfunc</code> as well, do

 

* Obtaining the return value of a function

 

 

Notice that the returned value can be any evaluated expression.

You can ignore the return value of a function <code>myfunc</code> as follows:

 

 

But notice that if <code>myfunc</code> fails, the above expression returns the value produced by <code>myfunc</code>! To also ignore the success/failure of a function, do

 

 

* Stating whether arguments are passed by value or by reference

There is no special syntax for that, but you can write a function that e.g., can take a list with one or with two elements and that returns a function in the first case.

 

= a b

. !arg:%?a ?b

<pre>1+2, not partial: 3

1+2, partial: 3</pre>

=={{header|C}}==

f();

 

/* Scalar values are passed by value by default. However, arrays are passed by reference. */

/* Pointers *sort of* work like references, though. */</syntaxhighlight>

=={{header|C sharp|C#}}==

/* a function that has no argument */

public int MyFunction();

int returnValue = MyFunction();

</syntaxhighlight>

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

 

/* function with no arguments */

</syntaxhighlight>

 

/* passing arguments by value*/

/* function with one argument */

</syntaxhighlight>

 

/* get return value of a function */

variable = function(args);

</syntaxhighlight>

 

#include <iostream>

using namespace std;

}

</syntaxhighlight>

=={{header|Clojure}}==

Note: I ran all these examples in the REPL so there is no printed output; instead I have denoted the value of each expression evaluated using `;=>'.

 

'''Calling a function that requires no arguments'''

(defn one []

"Function that takes no arguments and returns 1"

</syntaxhighlight>

'''Calling a function with a fixed number of arguments'''

(defn total-cost [item-price num-items]

"Returns the total price to buy the given number of items"

'''Calling a function with optional arguments'''

The syntax is exactly the same for the calling code; here's an example of the exact same function as above, except now it takes an optional third argument (discount-percentage)

(defn total-cost-with-discount [item-price num-items & [discount-percentage]]

"Returns total price to buy the items after discount is applied (if given)"

 

Once again, calling the function is the same, but you need to know what types of arguments are expected for each arity.

(defn make-address

([city place-name] (str place-name ", " city))

'''Calling a function with named arguments'''

The way to do this in clojure is to pass the arguments as a map and destructure them by name in the function definition. The syntax is the same, but it requires you to pass a single map argument containing all of your arguments and their names.

(defn make-mailing-label [{:keys [name address country]}]

"Returns the correct text to mail a letter to the addressee"

'''Using a function in statement context'''

I'm not really sure what this means - you can use a function to assign a variable, but there aren't really statements

(defn multiply-by-10 [number]

(* 10 number))

 

You can use one function to create another

(defn make-discount-function [discount-percent]

"Returns a function that takes a price and applies the given discount"

 

You can store functions in collections as if they were variables

;; Continuing on the same example, let's imagine Anna has a 20% discount card and Bill has 50%. Charlie pays full price

;; We can store their discount functions in a map

</syntaxhighlight>

You can pass functions as arguments to other functions

 

(defn format-price-uk [price]

</syntaxhighlight>

'''Obtaining the return value of a function'''

 

(def receipt-us (format-receipt "Toilet Paper" 5 format-price-us))

</syntaxhighlight>

'''Distinguishing built-in functions and user-defined functions'''

 

;; Using built-in addition

</syntaxhighlight>

'''Distinguishing subroutines and functions'''

;; Functions without return values simply return nil

 

All data structures are immutable, so they are passed by value only.

The value returned from the function does not change the original input

(def the-queen {:name "Elizabeth"

:title "Your Majesty"

Yes, it is similar to the discount card case we saw earlier. Instead of having a function return another function, we can use partial:

 

"Function to apply a discount to a price"

(-> price

(discount-10pc-option-2 100); => 90

</syntaxhighlight>

=={{header|CoffeeScript}}==

# Calling a function that requires no arguments

foo()

add2 1 #=> 3

</syntaxhighlight>

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

;Calling a function that requires no arguments

(defun a () "This is the 'A' function")

(funcall (curry #'+ 1) 2)

</syntaxhighlight>

=={{header|Cubescript}}==

// No arguments

myfunction

if (strcmp $myfunction "") [echo builtin function] // false

</syntaxhighlight>

=={{header|D}}==

 

enum isSubroutine(alias F) = is(ReturnType!F == void);

<pre>true

false</pre>

=={{header|Dart}}==

// Function definition

// See the "Function definition" task for more info

var value = returnsValue();

}</syntaxhighlight>

=={{header|Delphi}}==

Delphi allows everything what [[#Pascal|Pascal]] allows.

 

Calling a function without arguments and obtaining its return value:

Calling a function with optional arguments:

Calling a function with a variable number of arguments:

Using a function in a statement context:

foo;

writeLn('Goodbye world')</syntaxhighlight>

Like above, an empty parameter list, i. e. <tt>()</tt>, could be supplied too.

=={{header|Dragon}}==

 

* Calling a function that requires no arguments

 

* Calling a function with a fixed number of arguments

=={{header|Dyalect}}==

 

Calling a function that requires no arguments:

 

foo()</syntaxhighlight>

 

Calling a function with a fixed number of arguments:

 

foo(1, 2, 3)</syntaxhighlight>

 

Calling a function with optional arguments:

 

foo(1)</syntaxhighlight>

 

Calling a function with a variable number of arguments:

 

foo(1, 2, 3)</syntaxhighlight>

 

Calling a function with named arguments:

 

foo(z: 3, x: 1, y: 2)</syntaxhighlight>

 

Using a function in statement context:

 

if true {

foo()

Using a function in first-class context within an expression:

 

var x = if foo() {

1

Obtaining the return value of a function:

 

var x = 2

var y = foo(x)</syntaxhighlight>

Distinguishing built-in functions and user-defined functions:

 

//There is no actual difference between these functions and user-defined functions

 

Distinguishing subroutines and functions:

 

func foo() { } //doesn't explicitly return something (but in fact returns nil)

func bar(x) { return x * 2 } //explicitly returns value (keyword "return" can be omitted)</syntaxhighlight>

Stating whether arguments are passed by value or by reference:

 

 

Is partial application possible and how:

 

func apply(fun, fst) { snd => fun(fst, snd) }

 

var sub3 = apply(flip(sub), 3)

x = sub3(9) //x is 6</syntaxhighlight>

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

# calling a function with no arguments:

random-int

# a function's arity is a property of its behavior and not

# of its definition</syntaxhighlight>

=={{header|Elena}}==

ELENA 4.1:

Declaring closures

var c0 := { console.writeLine("No argument provided") };

var c2 := (int a, int b){ console.printLine("Arguments ",a," and ",b," provided") };

</syntaxhighlight>

Calling a closure without arguments

c0();

</syntaxhighlight>

Calling a closure with arguments

c2(2,4);

</syntaxhighlight>

Passing arguments by reference:

var exch := (ref object x){ x := 2 };

var a := 1;

exch(ref a);

</syntaxhighlight>

=={{header|Elixir}}==

 

# Anonymous function

 

end

</syntaxhighlight>

=={{header|Erlang}}==

no_argument()

one_argument( Arg )

% Partial application is possible (a function returns a function that has one argument bound)

</syntaxhighlight>

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

noArgs()

 

// Partial application example

let add2 = (+) 2</syntaxhighlight>

=={{header|Factor}}==

* Calling a word with no arguments:

 

* Calling a word with a fixed number of arguments. This will pull as many objects as it needs from the stack. If there are not enough, it will result in a stack underflow.

 

* No special support for optional arguments.

 

* Variable arguments are achieved by defining a word that takes an integer, and operates on that many items at the top of the stack:

! { "a" "b" "c" }</syntaxhighlight>

 

* The named arguments idiom is to define a tuple, set its slots, and pass it to a word:

"jack@aol.com" >>from

{ "jill@aol.com" } >>to

 

* First-class context: this pushes a word to the stack. Use execute to evaluate.

Additionally, you can put words directly inside sequences and quotations for deferred execution:

 

* Obtaining the return value, which will be placed on the stack:

 

* Returns true if the word is defined in the Factor VM as opposed to in a vocabulary. It should be noted that there are very few primitives.

 

* Factor makes no distinction between subroutines and functions.

 

* Partial application is possible by use of curry. Here, the object 2 is curried into the left side of the quotation (anonymous function) <tt>[ - ]</tt>:

! { -1 0 1 }</syntaxhighlight>

=={{header|Forth}}==

a-function \ with a fixed number of arguents

a-function \ having optional arguments

: right ( n -- ) 0 move ;

: left ( n -- ) negate right ;</syntaxhighlight>

=={{header|Fortran}}==

===Examples===

implicit none

integer :: a

As described in [[Naming_conventions#Fortran|Naming Conventions]], First Fortran (1958) allowed user-written functions but with restrictions on the names so that an ordinary variable called SIN would be disallowed because it was deemed to be in conflict with the library function SINF. These constraints were eased with Fortran II, and the rule became that a user could employ any correct-form name, such as SQRT, for a variable's name (simple or array) but then the library function SQRT would become inaccessible in such a routine. Similarly, there would be no point in the user writing a function called SQRT, because it could not be invoked - the compiler would take any invocation as being for the library routine SQRT. Thus, a user-written function could perhaps chance to have the name of an obscure (i.e. one forgotten about) library function, but if you were lucky it would have conflicting parameters and the compiler will complain.

 

DIST(X,Y,Z) = SQRT(X**2 + Y**2 + Z**2) + this/that !One arithmetic statement, possibly lengthy.

...

This flexibility in naming can be turned the other way around. For example, some compilers offer the intrinsic function SIND which calculates ''sine'' in degrees. Simply defining an array <code>REAL SIND(0:360)</code> (and properly initialising it) enables the slowish SIND function to be approximated by the faster indexing of an array. Put another way, an array is a function of a limited span of integer-valued arguments and is called in arithmetic expressions with the same syntax as is used for functions, be they intrinsic or user-written. Those writing in Pascal would be blocked by its insistence that arrays employ [] rather than (). Similarly, when testing, an array's declaration might be commented out and a function of that name defined, which function could check its arguments, write to a log file, note time stamps, or whatever else comes to mind. But alas, there is no "palindromic" or reverse-entry facility whereby a function could handle the assignment of a value ''to'' an array that would make this fully flexible.

 

IF (blah) H = 3*H - 7</syntaxhighlight>

As written, the appearance of <code>H</code> on the right-hand side of an expression does ''not'' constitute a call of function <code>H</code> at all. Some compilers fail to deal with this as hoped, and so one must use a scratch variable such as <code>FH</code> to develop the value, then remember to ensure that the assignment <code>H = FH</code> is executed before exiting the function, by whatever route. If the result is a large datum (a long character variable, say) this is annoying.

With the belated recognition of recursive possibilities (introduced by Algol in the 1960s) comes the possibility of a function invoking itself. In the above example, <code>H(3.7,5.5,6.6)</code> would clearly be a function invocation (because of the parentheses) whereas <code>H</code> would not be. Actually, Fortran routines have always been able to engage in recursion, it is just the returns that will fail - except on a stack-based system such as the Burroughs 6700 in the 1970s.

 

EXTERNAL F !Some function of one parameter.

REAL A,B !Bounds.

This works because Fortran passes parameters by reference (i.e. by giving the machine address of the entity), so that for functions, the code's entry point for the function is passed. With normal variables this means that a function (or subroutine) might modify the value of a parameter, as well as returning the function's result - and also mess with any COMMON data or other available storage, so a function EATACARD(IN) might read a line of data into a shared work area (called say ACARD) from I/O unit number IN and return ''true'', otherwise ''false'' should it hit end-of-file.

 

CHARACTER*12 NAME

INTEGER STUFF

TYPE(MIXED) LOTS(12000)</syntaxhighlight>

One might hope to try <code>IT = BCHOP(LOTS.NAME,"Fred")</code> where BCHOP is a well-tested function for performing a binary search that should run swiftly. Alas, no. The successive values of NAME are not contiguous while BCHOP expects to receive an array of values that are contiguous - that is, with a "stride" of one. So, the compiler inserts code to copy all the LOTS.NAME elements into such a work area and passes the location of that to BCHOP (which searches it swiftly), then on return, the work area is copied back to LOTS.NAME just in case there had been a change. This latter can be avoided if within BCHOP its array is given the attribute INTENT(IN) for read-only but the incoming copy still means an effort of order N, while for the search the effort is just Log(N). This can have a less-than-subtle effect if large arrays are involved.

=={{header|Fortress}}==

component call_a_function

export Executable

end

</syntaxhighlight>

=={{header|FreeBASIC}}==

Sub Saludo()

Print "Hola mundo!"

 

1, 2, 3, 4, cadena, 6, 7, 8, \'incluye texto\'</pre>

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=1bbbeb240f6fbca4b893271f1a19833b Click this link to run this code]'''<br>

Some of the uses of Procedures/Functions in Gambas

 

Hello

Hello Hello Hello!!

</pre>

=={{header|Go}}==

The following examples use functions from the standard packages

plus a few dummy local functions:

"image"

"image/gif"

func h(string, ...int) {}</syntaxhighlight>

* Calling with no arguments and calling with a fixed number of arguments:

g(1, 2.0)

// If f() is defined to return exactly the number and type of

g(g(1, 2.0), 3.0)</syntaxhighlight>

* Calling with a variable number of arguments:

h("ex2", 1, 2)

h("ex3", 1, 2, 3, 4)

//h("fail", 2, list...)</syntaxhighlight>

* Optional arguments and named arguments are not supported.

* Optional arguments are supported.

 

import "fmt"

}</syntaxhighlight>

* Named arguments are supported.

 

import "fmt"

}</syntaxhighlight>

* Within a statement context.

* In a first-class context:

if unicode.IsSpace(r) {

return -1

strings.Map(func(r rune) rune { return r + 1 }, "shift")</syntaxhighlight>

* Obtaining the value:

_, c := f() // only some of a multivalue return

d := g(a, c) // single return value

e, i := g(d, b), g(d, 2) // multiple assignment</syntaxhighlight>

* Built-in functions and user defined functions can not be distinguished.

i = len(list)</syntaxhighlight>

* Go has no subroutines, just functions and methods.

::As with C, a pointer can be used to achieve the effect of reference passing. (Like pointers, slice arguments have their contents passed by reference, it's the slice header that is passed by value).

* Go arguments are passed by value or by reference

 

import "fmt"

* Partial and Currying is not directly supported.

::However something similar can be done, see [[Partial function application#Go]]

 

import "fmt"

fmt.Println(partial(5)) //prt 18

}</syntaxhighlight>

=={{header|Groovy}}==

There are two types of first-class functions in Groovy.

 

* Calling a function that requires no arguments

 

* Calling a function with a fixed number of arguments

 

* Calling a function with optional arguments

optArgs("It's", "a", "beautiful")

optArgs("It's", "a")

 

* Calling a function with a variable number of arguments

varArgs("It's", "a", "beautiful")

varArgs("It's", "a")

 

* Using a function in statement context

 

* Using a function in first-class context within an expression

** Create new functions from preexisting functions at run-time

def newFunc = oldFunc.curry(30)

assert newFunc(12) == 42</syntaxhighlight>

** Store functions in collections

** Use functions as arguments to other functions

def changedList = list.collect(eltChangeFunc)</syntaxhighlight>

** Use functions as return values of other functions

caps ? { String transString -> ((transString + s) * reps).toUpperCase() }

: { String transString -> (transString + s) * reps }

 

* Obtaining the return value of a function

 

* Distinguishing built-in functions and user-defined functions

* Is partial application possible and how

Partial application in Groovy is performed via currying (demonstrated above)

=={{header|Haskell}}==

 

-- Calling a function with a fixed number of arguments

multiply x y = x * y

-- Stating whether arguments are passed by value or by reference

</syntaxhighlight>

=={{header|i}}==

//Eg. numbers are passed by value and lists/arrays are passed by reference.

 

}

</syntaxhighlight>

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

Icon and Unicon have generalized procedures and syntax that are used to implement functions, subroutines and generators.

For more information see [[Icon%2BUnicon/Intro|Icon and Unicon Introduction on Rosetta]]

 

 

# normal procedure/function calling

f("x:=",1,"y:=",2) # named parameters (user defined)

end</syntaxhighlight>

=={{header|J}}==

 

A verb, in J, typically supports two syntactic variants:

 

noun verb noun</syntaxhighlight>

 

An argument list can be represented by an array. Thus, when dealing with multiple arguments, a typical form is:

 

 

Here, <code>function</code> is a verb and <code>argumentList</code> is a noun.

For example:

 

 

Here <code>sum</code> is a verb and <code>(1,2,3)</code> is a noun.

Thus:

 

 

 

 

''A function with a variable number of arguments (varargs)'': See above.

 

 

george__obj=: 1

tom__obj=: 2

howard__obj=: 3

f obj

 

''Using a function in command context'' is no different from using a function in any other context, in J. ''Using a function in first class context within an expression'' is no different from using a function in any other context, in J.

 

 

The only ''differences that apply to calling builtin functions rather than user defined functions'' is spelling of the function names.

 

There are no ''differences between calling subroutines and functions'' because J defines neither <code>subroutines</code> nor <code>functions</code>. Instead, J defines <code>verbs</code>, <code>adverbs</code>, and <code>conjunctions</code> which for the purpose of this task are treated as functions. (All of the above examples used verbs. J's adverbs and conjunctions have stronger [[wp:Valence|valence]] than its verbs.)

=={{header|Java}}==

Java does not have functions, but Java classes have "methods" which are equivalent.

 

* Calling a function that requires no arguments

We didn't specify an object (or a class) as the location of the method, so <tt>this.myMethod()</tt> is assumed. This applies to all the following examples.

 

* Calling a function with a fixed number of arguments

 

* Calling a function with optional arguments

This is possible if the method name is overloaded with different argument lists. For example:

// return result of doing sums with a and b

}

 

The compiler figures out which method to call based on the types of the arguments, so in this case the second argument appears to be optional. If you omit it, the value <tt>1.414</tt> is used.

System.out.println( myMethod( 97 ) );</syntaxhighlight>

 

* Calling a function with a variable number of arguments

This is possible if the method is defined with varargs syntax. For example:

for ( String s : strings )

System.out.println( s );

 

The type of <tt>strings</tt> is actually a string array, but the caller just passes strings:

printAll( "Freeman", "Hardy", "Willis" );</syntaxhighlight>

 

* Calling a function with named arguments

Not directly possible, but you could simulate this (somewhat verbosely):

return

((Integer)params.get("x")).intValue()

 

Called like this:

 

Yuk.

 

* Obtaining the return value of a function

 

* Distinguishing built-in functions and user-defined functions

* Stating whether arguments are passed by value or by reference

All arguments are passed by value, but since object variables contain a reference to an object (not the object itself), objects appear to be passed by reference. For example:

// If I change the contents of the list here, the caller will see the change

}</syntaxhighlight>

* Is partial application possible and how

Don't know

=={{header|JavaScript}}==

 

The arguments to a JavaScript function are stored in a special array-like object which does not enforce arity in any way; a function declared to take ''n'' arguments may be called with none‒and vice versa‒without raising an error.

 

foo() // 0

foo(1, 2, 3) // 3</syntaxhighlight>

 

JavaScript functions are first-class citizens; they can be stored in variables (see above) and passed as arguments.

 

Naturally, they can also be returned, thus partial application is supported.

var make_adder = function(m) {

return function(n) { return m + n }

Calling a user-defined function's <tt>toString()</tt> method returns its source verbatim; that the implementation is elided for built-ins provides a mechanism for distinguishing between the two.

 

"function () { return arguments.length }"

alert.toString()

 

Arguments are passed by value, but the members of collections are essentially passed by reference and thus propagate modification.

victim[0] = null;

victim = 42;

var foo = [1, 2, 3];

mutate(foo) // foo is now [null, 2, 3], not 42</syntaxhighlight>

=={{header|jq}}==

jq functions are pure functions that are somewhat unusual in two respects:

 

See [[Currying#jq]].

=={{header|Julia}}==

# Calling a function that requires no arguments:

f() = print("Hello world!")

map(x -> f(x, 10), v) # v = [30, 52, 82]

</syntaxhighlight>

=={{header|Kotlin}}==

In Kotlin parameters are always passed by value though, apart from the (unboxed) primitive types, the value passed is actually a reference to an object.

 

fun fun1() = println("No arguments")

Hello world

</pre>

=={{header|Lambdatalk}}==

In lambdatalk functions are abstractions {lambda {args} body} whose behaviour is best explained as a part of such a complete expression {{lambda {args} body} values}.

 

The command

More can be seen in http://lambdaway.free.fr/lambdawalks/?view=lambda

</syntaxhighlight>

=={{header|langur}}==

User-defined and built-in functions can be called using parentheses.

 

=== parentheses ===

# call user-defined function</syntaxhighlight>

 

# call built-in with parentheses</syntaxhighlight>

 

=== unbounded lists ===

# call built-in with unbounded list</syntaxhighlight>

 

# unbounded lists on writeln and join

# later function join takes remaining arguments</syntaxhighlight>

 

# unbounded list on writeln

# join using parentheses so it doesn't take remaining arguments</syntaxhighlight>

 

f(.sum, .i, .c) .sum + toNumber(.c, 36) x .weight[.i],

0,

# split, pseries, and len using unbounded lists, ending before comma preceding line return</syntaxhighlight>

 

...

}

# unbounded list on keys bounded by closing parenthesis of sort</syntaxhighlight>

=={{header|Latitude}}==

 

Like Ruby, Latitude doesn't have functions in the traditional sense, only methods. Methods can be called with parentheses, as in many languages. If a method takes no arguments, the parentheses may be omitted. If a method takes a single argument and that argument is a literal (such as a literal number or string), then the parentheses may also be omitted. Additionally, Latitude provides an alternative syntax for method calls which replaces the parentheses with a colon.

 

foo (). ; (2) No arguments

foo. ; (3) Equivalent to (2)

Although methods themselves can be passed around as first-class values, the method evaluation semantics often make such an approach suboptimal. If one needs a first-class function in the traditional sense, the usual approach is to wrap it in a <code>Proc</code> object and then call it explicitly as needed.

 

myProc call (1, 2, 3).</syntaxhighlight>

 

If you want to write a function which can accept either a <code>Proc</code> or a method object (as many standard library functions do, for convenience), you may use the <code>shield</code> method to ensure that the object is a <code>Proc</code>. <code>shield</code> wraps methods in a <code>Proc</code> while leaving objects which are already procedures alone.

 

myProc2 := proc { foo. }.

myProc3 := proc { foo. } shield.</syntaxhighlight>

 

All three of the above procedures will act the same.

=={{header|LFE}}==

 

 

In some module, define the following:

(defun my-func()

(: io format '"I get called with NOTHING!~n"))

 

Then you use it like so (depending upon how you import it):

> (my-func)

I get called with NOTHING!

'''Calling a function with a fixed number of arguments:'''

In some module, define the following:

(defun my-func(a b)

(: io format '"I got called with ~p and ~p~n" (list a b)))

 

Then you use it like so:

> (my-func '"bread" '"cheese")

I got called with "bread" and "cheese"

* One can define multiple functions so that it ''appears'' that one is calling a function with optional or a variable number of arguments:

 

(defmodule args

(export all))

 

Here is some example usage:

> (slurp '"args.lfe")

#(ok args)

 

'''Using a function in statement context:'''

...

(cond ((== count limit) (hit-limit-func arg-1 arg-2))

 

From the LFE REPL:

> (>= 0.5 (: math sin 0.5))

true

 

There are many, many ways to assign function outputs to variables in LFE. One fairly standard way is with the <code>(let ...)</code> form:

(let ((x (: math sin 0.5)))

...)

* Not explicitly.

* However, one can use <code>lambda</code>s to achieve the same effect.

=={{header|Liberty BASIC}}==

'Call a function - Liberty BASIC

 

'impossible

</syntaxhighlight>

=={{header|Lingo}}==

 

*Calling a function that requires no arguments

-- or alternatively:

call(#foo, _movie)</syntaxhighlight>

 

*Calling a function with a fixed number of arguments

-- or alternatively:

call(#foo, _movie, 1, 2, 3)</syntaxhighlight>

 

*Calling a function with optional arguments

if voidP(b) then b = 1

return a * b

end</syntaxhighlight>

-- 46

put foo(23)

 

*Calling a function with a variable number of arguments

res = 0

repeat with i = 1 to the paramCount

return res

end</syntaxhighlight>

-- 6</syntaxhighlight>

 

*Using a function in first-class context within an expression

Lingo has no first-class functions, but the call(...) syntax (see above) allows to identify and use functions specified as "symbols" (e.g. #foo). This allows some "first-class alike" features:

-- One of the five native iterative methods defined in ECMAScript 5

-- @param {list} tList

return n*2

end</syntaxhighlight>

put map(l, #doubleInt)

-- [2, 4, 6]</syntaxhighlight>

 

*Obtaining the return value of a function

 

*Distinguishing built-in functions and user-defined functions

In Lingo all user-defined (global) functions are 'methods' of the _movie object, and there is AFAIK no direct way to distinguish those from _movie's built-in functions. But by iterating over of all movie scripts in all castlibs you can get a complete list of all user-defined (global) functions, and then any function not in this list is a built-in function:

res = []

repeat with i = 1 to _movie.castlib.count

return res

end</syntaxhighlight>

-- [#sum, #double, #getAllUserFunctions]</syntaxhighlight>

 

*Stating whether arguments are passed by value or by reference

In lingo 'objects' are always passed by reference, all other types (e.g. strings, integers, floats) by value. 'Objects' are e.g. lists (arrays), property lists (hashes), images and script instances. The built-in function objectP() returns TRUE (1) for objects and FALSE (0) for non-objects. To prevent the effects of call-by-reference, some object types (lists, property lists and images) support the method duplicate() to clone the object before passing it to a function:

cnt = someList.count

repeat with i = 1 to cnt

end repeat

end</syntaxhighlight>

double(l)

put l

put l

-- [1, 2, 3]</syntaxhighlight>

=={{header|Little}}==

 

local fuctions.

 

void foo() {puts("Calling a function with no arguments");}

foo();

puts (b);

}</syntaxhighlight>

=={{header|Lua}}==

function fixed (a, b, c) print(a, b, c) end

fixed() --> nil nil nil

-- Built-in functions are not easily distinguishable from user-defined functions

</syntaxhighlight>

=={{header|Luck}}==

f();;

 

/* Is partial application possible and how */

tasty_curry(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)(r)(s)(t)(u)(v)(w)(x)(y)(z);;</syntaxhighlight>

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

<pre>

 

</pre>

=={{header|Maple}}==

Distinguishing built-in functions and user-defined functions:

true

</syntaxhighlight>

 

Partial application is supported by the <code>curry</code> and <code>rcurry</code> commands.

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

Calling a function that requires no arguments:

 

Calling a function with a fixed number of arguments:

 

Calling a function with optional arguments:

 

Calling a function with a variable number of arguments:

f[1,Option1->True,Option2->False]</syntaxhighlight>

 

Calling a function with named arguments:

 

Using a function in statement context:

 

Using a function in first-class context within an expression:

 

The return value of a function can be formally extracted using Return[]

No formal distinction between subroutines and functions.

Arguments can be passed by value or by reference.

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

% Calling a function that requires no arguments

function a=foo();

% arguments are passed by value, however Matlab has delayed evaluation, such that a copy of large data structures are done only when an element is written to.

</syntaxhighlight>

=={{header|Nanoquery}}==

no_args()

 

println "func is a built-in or doesn't exist"

end</syntaxhighlight>

=={{header|Nemerle}}==

f()

 

def a = g(3) // equivalent to: def a = f(2, 3)

def b = h(3) // equivalent to: def b = f(3, 2)</syntaxhighlight>

=={{header|Nim}}==

Translated from Python, when possible:

discard

# call

let y = 19.return_something() + 10

let z = 19.return_something + 10</syntaxhighlight>

=={{header|OCaml}}==

 

* Calling a function that requires no arguments:

 

 

(In fact it is impossible to call a function without arguments, when there are no particular arguments we provide the type <code>unit</code> which is a type that has only one possible value. This type is mainly made for this use.)

* Calling a function with a fixed number of arguments:

 

 

* Calling a function with optional arguments:

For a function that has this signature:

 

 

here is how to call it with or without the first argument omited:

 

f ~a:6 10</syntaxhighlight>

 

Due to partial application, an optional argument always has to be followed by a non-optional argument. If the function needs no additional arguments then we use the type <code>unit</code>:

 

g ~b:1.0 ()</syntaxhighlight>

 

Named arguments are called '''labels'''.

 

 

If a variable has the same name than the label we can use this simpler syntax:

 

f ~arg</syntaxhighlight>

 

* Using a function in statement context:

 

 

* Using a function in first-class context within an expression:

* Obtaining the return value of a function:

 

let a, b, c = f () (* if there are several returned values given as a tuple *)

let _ = f () (* if we want to ignore the returned value *)

 

With partial application, the arguments are applied in the same order than they are defined in the signature of the function, except if there are labeled arguments, then it is possible to use these labels to partially apply the arguments in any order.

=={{header|Oforth}}==

 

 

If f is a function and c b a ares objects :

will push c then b then a on the stack then call f. Calling f does not describe if f will use 1, 2 or 3 arguments (or none).

 

Oforth adds a notation to describe parameters used by a function. It is only a way to add information about which parameters will be used by f :

 

Intepreter will replace this second syntax by the first one. It is only "sugar"...

 

a b f(c)

a f(b, c)

Methods need a receiver (the object on which the method will apply and the object that will pushed on th stack when self is used into the method body).

The receiver must be on the top of the stack before calling the method. If a, b, c and r are objects and m a method :

will call m with r as its receiver.

It is also possible to use the same "sugar" notation used by functions :

=={{header|Ol}}==

; note: sign "==>" indicates expected output

 

; The values in Ol always passed as values and objects always passed as references. If you want to pass an object copy - make a copy by yourself.

</syntaxhighlight>

=={{header|ooRexx}}==

This is to show how a built-in function is invoked when an internal function on the dame name in present.

Say date()

Exit

31 Mar 2022

my date</pre>

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

Calling a function is done in GP by writing the name of the function and the arguments, if any, in parentheses. As of version 2.5.0, function calls must use parentheses; some earlier versions allowed functions with an arity of 0 to be called without parentheses. However built-in constants (which are implicit functions of the current precision) can still be called without parentheses.

 

Functions can be used when statements would be expected without change.

sin(Pi/2); \\ fixed number of arguments

vecsort([5,6]) != vecsort([5,6],,4) \\ optional arguments

 

Most arguments are passed by reference. Some built-in functions accept arguments (e.g., flags) that are not <code>GEN</code>s; these are passed by value or reference depending on their [[C]] type. See the User's Guide to the PARI Library section 5.7.3, "Parser Codes".

=={{header|Pascal}}==

''see also: [[#Delphi|Delphi]] and [[#Free Pascal|Free Pascal]]''

 

Calling a nullary function and obtaining its return value:

Calling an n-ary function (n ≥ 1) and obtaining its return value:

 

Following are not possible in Pascal as defined by the ISO standards (ISO 7185 and ISO 10206).

* stating ''at the call site'' whether arguments are passed by value or by reference

* partial application

=={{header|Perl}}==

The most common syntax; simply calls the function foo on the argument(s) provided.

&foo(); # Ditto

foo($arg1, $arg2); # Call foo on $arg1 and $arg2

Call foo() as a bareword. Only works after the function has been declared, which

can be done normally or with the use subs pragma.

&{$fooref}('foo', 'bar');

$fooref->('foo', 'bar');</syntaxhighlight>

=={{header|Phix}}==

{{libheader|Phix/basics}}

* Phix does not allow implicit discard of function results. The explicit discard statement takes the form

 

<span style="color: #0000FF;">{<span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">myfunction<span style="color: #0000FF;">(<span style="color: #0000FF;">)

<!--</syntaxhighlight>-->

* This is in fact a simple contraction of standard multiple assigment (which can be nested as deeply as you like):

 

<span style="color: #0000FF;">{<span style="color: #000000;">cities<span style="color: #0000FF;">,<span style="color: #000000;">populations<span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">columnize<span style="color: #0000FF;">(<span style="color: #000000;">muncipalities<span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">{<span style="color: #0000FF;">{<span style="color: #0000FF;">}<span style="color: #0000FF;">,<span style="color: #000000;">populations<span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">columnize<span style="color: #0000FF;">(<span style="color: #000000;">muncipalities<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- discard result[1]</span>

* Optional arguments are denoted simply by the presence of a default, and must be grouped on the right:

 

<span style="color: #008080;">function</span> <span style="color: #000000;">myfunction<span style="color: #0000FF;">(<span style="color: #004080;">integer</span> <span style="color: #000000;">a<span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">b<span style="color: #0000FF;">=<span style="color: #008000;">"default"<span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #0000FF;">{<span style="color: #000000;">a<span style="color: #0000FF;">,<span style="color: #000000;">b<span style="color: #0000FF;">}</span>

* Named arguments can be specified in any order, with an error if any non-optional parameters are missing:

 

<span style="color: #0000FF;">?<span style="color: #000000;">myfunction<span style="color: #0000FF;">(<span style="color: #000000;">b<span style="color: #0000FF;">:=<span style="color: #008000;">"then"<span style="color: #0000FF;">,<span style="color: #000000;">a<span style="color: #0000FF;">:=<span style="color: #000000;">3<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- displays {3,"then"}

--?myfunction(b:="though") -- compile-time error

* Phix support first-class functions directly, as integers, along with an older routine_id mechanism:

 

<span style="color: #008080;">constant</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">r_myfunction</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">routine_id<span style="color: #0000FF;">(<span style="color: #008000;">"myfunction"<span style="color: #0000FF;">)<span style="color: #0000FF;">,</span>

<span style="color: #000000;">first_class</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">myfunction</span>

* All arguments are passed by reference with copy-on-write semantics: to modify the value of a parameter you must both return and assign it, as in:

 

<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append<span style="color: #0000FF;">(<span style="color: #000000;">s<span style="color: #0000FF;">,<span style="color: #000000;">item<span style="color: #0000FF;">)

<!--</syntaxhighlight>-->

 

* Implicit forward calls are supported, as are optional explicit forward declarations, which can occasionally cure compilation error messages.

=={{header|Phixmonti}}==

"Hola mundo" print nl

enddef

 

getid saludo exec</syntaxhighlight>

=={{header|PicoLisp}}==

When calling a funcion in PicoLisp directly (does this mean "in a statement context"?), it is always surrounded by parentheses, with or without arguments, and for any kind of arguments (evaluated or not):

(bar 1 'arg 2 'mumble)</syntaxhighlight>

When a function is used in a "first class context" (e.g. passed to another function), then it is not yet '''called'''. It is simply '''used'''. Technically, a function can be either a '''number''' (a built-in function) or a '''list''' (a Lisp-level function) in PicoLisp):

(apply '((A B C) (foo (+ A (* B C)))) (3 5 7)) # A list is passed</syntaxhighlight>

Any argument to a function may be evaluated or not, depending on the function. For example, 'setq' evaluates every second argument

i.e. the first argument 'A' is not evaluated, the second evaluates to 7, 'B' is not evaluated, then the fourth evaluates to 12.

=={{header|PureBasic}}==

{{trans|FreeBASIC}}

PrintN("Hola mundo!")

EndProcedure

{{out}}

<pre>Same as FreeBASIC entry.</pre>

=={{header|Python}}==

Under the hood all Python function/method parameters are named. All arguments can be passed as ''name=value'' pairs or as a dictionary containing such pairs using the ''myfunc('''**key_args''')'' (apply over dictionary) syntax). One can also "apply" a function over a sequence of arguments using the syntax: ''myfunc('''*args''')'' as noted in comments below. Parameters can be mixed so long parameters with default values (optional arguments) follow any "positional" (required) parameters, and catchall parameter ('''''*args''''') follow those, and any "keyword arguments' parameter" is last. (Any function can only have up to one "catchall" or '''''*args'''' parameter and up to one "keyword args" '''''**kwargs''''' parameter).

pass

# call

## For partial function application see:

## http://rosettacode.org/wiki/Partial_function_application#Python</syntaxhighlight>

=={{header|QBasic}}==

{{works with|QBasic|1.1}}

{{works with|QuickBasic|4.5}}

{{trans|FreeBASIC}}

DIM nuevaCadena$

Igual que la entrada de FreeBASIC.

</pre>

=={{header|Quackery}}==

 

Stack empty.

</pre>

=={{header|R}}==

Translated from Python, when possible.

no_args <- function() NULL

no_args()

### Is partial application possible and how

# Yes, see http://rosettacode.org/wiki/Partial_function_application#R</syntaxhighlight>

=={{header|Racket}}==

 

#lang racket

 

(λ(x) (foo 1 2 x)) ; a direct way of doing the same

</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

Calling a function that requires no arguments:

 

foo() # as function

foo.() # as function, explicit postfix form

Calling a function with exactly one argument:

 

foo(1) # as named function

foo.(1) # as named function, explicit postfix

Calling a function with exactly two arguments:

 

foo(1,2) # as named function

foo.(1,2) # as named function, explicit postfix

Calling a function with a variable number of arguments (varargs):

 

foo(@args) # as named function

foo.(@args) # as named function, explicit postfix

foo function is declared with a signature of the form (*@params). The calls above might be interpreted as having a single array argument if the signature indicates a normal parameter instead of a variadic one. What you cannot do in Raku (unlike Perl 5) is pass an array as several fixed arguments. By default it must either represent a single argument, or be part of a variadic list. You can force the extra level of argument list interpolation using a prefix <tt>|</tt> however:

 

foo(|@args); # equivalent to foo(1,2,3)</syntaxhighlight>

 

Calling a function with named arguments:

 

foo(:a, :b(4), :!c, d => "stuff")</syntaxhighlight>

 

colon adverbials are allowed:

 

 

Using a function in statement context:

 

 

Using a function in first class context within an expression:

 

 

Obtaining the return value of a function:

 

 

There is no difference between calling builtins and user-defined functions and operators (or

===Practice===

Demonstrating each of the above-mentioned function calls with actual running code, along with the various extra definitions required to make them work (in certain cases). Arguments are checked, and function name / run-sequence number are displayed upon success.

state $n;

 

{{out}}

<pre>f1 f2 i3 f4 f5 f6 f7 f8 f9 f10 l11 f12 f13 f14 f15 f16 f17 j18 j19 j20 f21 f22 m23 f24 f25 f26 f27 f28 f29 k30 k31 k32 f33 f34 n35 f36 f37 g38 g39 g40 g41 h42 h43 h44 f45</pre>

=={{header|REXX}}==

===version 1===

 

/*╔════════════════════════════════════════════════════════════════════╗

 

 

║ Calling a function with a fixed number of arguments. ║

║ ║

 

 

║ Calling a function with optional arguments. ║

║ ║

 

 

║ Calling a function with a variable number of arguments. ║

║ ║

 

 

║ Calling a function in statement context. ║

║ ║

 

 

║ Obtaining the return value of a function. ║

║ ║

 

 

║ Distinguishing built-in functions and user-defined functions. ║

║ ║

 

 

║ Distinguishing subroutines and functions. ║

║ ║

 

===version 2===

* 29.07.2013 Walter Pachl trying to address the task concisely

***********************************************************************

rc=44 (Function or message did not return data)

fb cannot be invoked as function (it does not return a value)</pre>

=={{header|Ring}}==

hello()

func hello

see "Hello from function" + nl

</syntaxhighlight>

first() second()

func first see "message from the first function" + nl

func second see "message from the second function" + nl

</syntaxhighlight>

sum(3,5) sum(1000,2000)

func sum x,y see x+y+nl

</syntaxhighlight>

# this program will print the hello world message first then execute the main function

See "Hello World!" + nl

see "Message from the main function" + nl

</syntaxhighlight>

=={{header|Ruby}}==

Ruby does not have functions, but Ruby classes have "methods" which are equivalent.

 

*Calling a function that requires no arguments

 

foo #=> "foo"

 

*Calling a function with a fixed number of arguments

 

foo(1) #=> 1

 

*Calling a function with optional arguments

 

foo #=> [0, 0, true]

 

*Calling a function with a variable number of arguments

 

foo #=> []

 

*Calling a function with named arguments

 

foo(age:22, name:"Tom") #=> [0, "Tom", 22]</syntaxhighlight>

 

*Obtaining the return value of a function

 

bar = foo 10,20

::These methods are called without a receiver and thus can be called in functional form.

 

raise "Error input" # Kernel#raise

Integer("123") # Kernel#Integer

::The block argument sends a closure from the calling scope to the method.

::The block argument is always last when sending a message to a method. A block is sent to a method using <code>do ... end</code> or <code>{ ... }</code>.

def sum(init=0, &blk)

if blk

:Splat operator:

::You can turn an Array into an argument list with * (or splat) operator.

 

args = [1,2,3]

:Syntax sugar:

::In Ruby, many operators are actually method calls.

i = 3

p 1 + i #=> 4 1.+(i)

p "%2d %4s" % [1,"xyz"] #=> " 1 xyz" "%2d %4s".%([1,"xyz"])</syntaxhighlight>

::Method call which was displayed in the comment is usable actually.

=={{header|Rust}}==

// Rust has a lot of neat things you can do with functions: let's go over the basics first

fn no_args() {}

 

}</syntaxhighlight>

=={{header|Scala}}==

{{libheader|Scala}}

def myFunction0() = ???

myFunction0() // function invoked with empty parameter list

// No distinction between built-in functions and user-defined functions

// No distinction between subroutines and functions</syntaxhighlight>

=={{header|Seed7}}==

* Seed7 provides two kinds of subroutines: ''proc'', which has no return value, and ''func'', which has a return value. The return value of a ''func'' must be used by the caller (e.g. assigned to a variable). If you don't want do deal with the return value, use a ''proc'' instead.

* All parameters are positional.

 

env := environment(); # Alternative possibility to call of a function with no arguments.

cmp := compare(i, j); # Call a function with a fixed number of arguments.</syntaxhighlight>

 

write("asdf"); # Variant of write which writes to the file OUT.</syntaxhighlight>

 

result

var integer: sum is 0;

t := sum([] (2, 3, 5, 7));</syntaxhighlight>

 

 

 

=={{header|SenseTalk}}==

* If no variable is specified, `put` prints the variable to stdout

 

// Function calls can also be made using the following syntax:

 

* Running a function requires a keyword such as `put; if no variable is return, put into e.g. _

 

// Alternatively, the function can be called like so:

 

* A parameter is set to "" if nothing is specified

 

function ThreeArgFn arg1, arg2, arg3

 

* Using this, default parameter values can be set up if a check if done at the start of the function

get OneArgFn(10) -- arg1 is now 10

 

* All variables are, by default, passed by value

* If the argument prefixed by 'container', the variable is passed by reference

get AddOne(a)

put "Value of a = " & a

 

SenseTalk also distinguishes between functions and subroutines, which it calls handlers:

// Prints: 1 - 2 - 3

 

 

Subroutines can be called as a command, without storing the output

MyCommand 1, "variable", (4, 5, 6)

 

 

Functions/subroutines can also be defined with the to, on or function keywords:

...

end MyFn

end args

</syntaxhighlight>

=={{header|Sidef}}==

All functions in Sidef are first-class closures

foo(1, 2); # with two arguments

foo(args...); # with a variable number of arguments

Partial application is possible by using a curry function:

 

func (*args2) {

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

var adder = curry(add, 1);

say adder(3); #=>4</syntaxhighlight>

=={{header|Smalltalk}}==

Where f is a closure and arguments is an array of values for f to operate on.

=={{header|SSEM}}==

Assuming the subroutine has been set up in accordance with the Wheeler jump technique as described in the SSEM [[Function definition]] entry, calling it requires simply loading the return address into the accumulator and jumping out to the subroutine. Parameters must be passed using "global variables", i.e. storage locations; results may be passed the same way, although it is also possible to pass a return value in the accumulator.

 

This code fragment, beginning (for the sake of argument) at address 10, performs a Wheeler jump to a subroutine beginning at address 20. The return address is coded in negative (two's complement) form because the SSEM negates values in the process of loading them into the accumulator. As always on the SSEM, jump targets are one less than the actual intended target: this is because the CI ("Current Instruction") register is incremented after an instruction has been executed rather than before.

10110000000000000000000000000000 11. 13 to CI

11001111111111111111111111111111 12. -13

11001000000000000000000000000000 13. 19</syntaxhighlight>

=={{header|Swift}}==

noArgs()

 

// getting a bunch of return values, discarding second returned value

let (foo, _, baz) = returnSomeValues()</syntaxhighlight>

=={{header|Tcl}}==

aCallToACommandWithOne argument

aCallToACommandWith arbitrarily many arguments

aCallToOneCommand [withTheResultOfAnother]</syntaxhighlight>

Tcl does differentiate between functions and other types of commands in expressions:

expr {func(1,2,3} + [cmd a b c]}</syntaxhighlight>

However, there are no deep differences between the two: functions are translated into commands that are called in a particular namespace (thus <tt>foo()</tt> becomes <tt>tcl::mathfunc::foo</tt>).

There are no differences in usage between built-in commands and user-defined ones, and parameters are passed to commands by value conceptually (and read-only reference in the implementation).

=={{header|True BASIC}}==

{{trans|FreeBASIC}}

FOR cont = 1 TO ROUND(siNo)

LET nuevaCadena$ = nuevaCadena$ & txt$

Igual que la entrada de FreeBASIC.

</pre>

=={{header|UNIX Shell}}==

 

In the shell, there are no argument specifications for functions. Functions obtain their arguments using the positional parameter facilities and functions are simply called by name followed by any arguments that are to be passed:

 

multiply 3 4 # Call a function in statement context with two arguments</syntaxhighlight>

 

The shell does not support the use of named parameters. There is no lookahead in the shell, so functions cannot be called until their definition has been run.

=={{header|VBA}}==

 

'Calling a function that requires no arguments

calling a subroutine does not require parentheses

deprecated use of parentheses</pre>

=={{header|WDTE}}==

noargs -- print;

 

# function.

(+ 3) 7 -- print;</syntaxhighlight>

=={{header|WebAssembly}}==

 

 

(local $result i32)

)

)</syntaxhighlight>

=={{header|Wren}}==

Wren distinguishes between functions and methods.

Here are some examples:

 

var f2 = Fn.new { |a, b|

System.print("Function 'f2' with 2 arguments called and passed %(a) & %(b).")

50

</pre>

=={{header|XLISP}}==

(foo)

 

(foo bar)

; nothing is done with the return value</syntaxhighlight>

=={{header|XSLT}}==

 

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

<xsl:output method="xml" indent="yes"/>

</xsl:stylesheet>

</syntaxhighlight>

=={{header|Yabasic}}==

sub test(a, b, c) : print a, b, c : end sub

 

test$("1, 2, 3, 4, text, 6, 7, 8, \"include text\"")

print</syntaxhighlight>

 

=={{header|zkl}}==

The syntax and semantics of function calls is the always the same: name/object(parameters). All calls are varargs, it is up to the callee to do default/optional parameter handling (but that is hidden from the programmer). No named parameters. Pass by reference or value, depending.

 

Using f has a function, method or object:

fcn f(a=1){}() // define and call f, which gets a set to 1

fcn{vm.arglist}(1,2,3,4) // arglist is L(1,2,3,4)

fcn{}.len.isType(self.fcn) //False, len is a Method</syntaxhighlight>

Partial application is done with the .fp* methods or the 'wrap keyword

fcn(a,b,c).fp(1)() // call function with a always set to 1

fcn(a,b,c).fp1(2,3)() // call function with b & c always set to 2 & 3

a:=5; f('wrap(b){a+b}) // 'wrap is syntactic sugar for .fpN

// to create a lexical closure --> f(fcn(b,a){a+b}.fpN(1,a))</syntaxhighlight>

=={{header|zonnon}}==

module CallingProcs;

type

end CallingProcs.

</syntaxhighlight>

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

 

On the ZX Spectrum, functions and subroutines are separate entities. A function is limited to being a single expression that generates a return value. Statements are not allowed within a function. A subroutine can perform input and output and can contain statements.

 

20 PRINT FN a(5): REM The function is used in first class context. Arguments are not named

30 PRINT FN b(): REM Here we call a function that has no arguments

110 PRINT RND(): REM here we use a builtin function without parameters

120 RANDOMIZE: REM statements are not functions and cannot be used in first class context.</syntaxhighlight>

{{omit from|GUISS}}