Call a function: Difference between revisions

{{trans|Python}}

// call

no_args()

// calls

opt_args() // 1

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

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

With:

Y DS F

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

* ...

PARMLIST DC A(X)

If you call a link-edited object-module:

If you call an load-module at execution time:

LR R15,R0 retrieve entry address

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

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

CLC

ADC $01 ;add the byte at memory address $0001

The return value is usually stored in the accumulator if it will fit in 8 bits. If not, it's often stored in a dedicated section of the zero page. Since the 6502 has very few registers and all are 8-bit, it's common to set aside a few zero page memory addresses for holding 16-bit return values.

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 the stack. When looking at the function in C or a similar language that compiles to 68000 Assembly, the arguments are pushed in the reverse order they are listed. Return values typically go into the D0 register if they're 32-bit or smaller. The CPU does not enforce this, so it's up to the programmer or compiler to use calling conventions to ensure compatibility between software.

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

push bp

mov bp,sp

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.

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

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program callfonct.s */

.include "../includeARM64.inc"

{{output}}

<pre>

=={{header|ActionScript}}==

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

=={{header|Ada}}==

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

...

A : Integer := F(12);

B : Integer := F(12, 0); -- the same as A

* 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;

...

A := Sum((1,2,3)); -- A = 6

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

return Integer);

X := H(A, F'Access) -- assuming X and A are Integers, and F is a function

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

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

# A function called without arguments: #

f;

# If the function is declared with argument(s) of mode REF MODE,

then those arguments are being passed by reference. #

See [http://rosettacode.org/wiki/First-class_functions#ALGOL_68 First-Class Functions] for an example of first-class functions in ALGOL 68.<br>

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

% calling a function with no parameters: %

f;

% parameters are somewhat like macros %

=={{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!"]

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

.Ls_magic_number_10: .word 0x66666667

=={{header|Arturo}}==

print "Hello World!"

]

print num

{{out}}

=={{header|AutoHotkey}}==

f()

; Partial application is impossible.

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

In awk, scalar values are passed by value, but arrays are passed by reference. Note that if a function has no arguments, then empty parentheses are required.

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

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

OPARG(1,2,3)

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.

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.

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

nuevaCadena$ = ""

print

call testCadenas("1, 2, 3, 4, cadena, 6, 7, 8, \#incluye texto\#")

{{out}}

<pre>

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.

endlocal & echo.%filepath%%filename%

goto:eof

Output:

<pre>

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.

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

Given a three element array, the above example will concatenate them all together.

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

& out$("1+2, not partial:" plus$(1 2))

& out$("1+2, partial:" (plus$1)$2)

Output:

=={{header|C}}==

f();

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

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

/* a function that has no argument */

public int MyFunction();

public internal MyFunction();

int returnValue = MyFunction();

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

/* function with no arguments */

foo();

/* passing arguments by value*/

/* function with one argument */

/* function with multiple arguments */

baz(arg1, arg2);

/* get return value of a function */

variable = function(args);

#include <iostream>

using namespace std;

cout<<"x = "<<x<<endl; /* should produce result "x = 1" */

}

=={{header|COBOL}}==

*> Fixed number of arguments.

ACCEPT Foo *> Get a PROGRAM-ID from the user.

CALL "Use-Func" USING Foo

=={{header|Clojure}}==

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

(defn one []

"Function that takes no arguments and returns 1"

(one); => 1

'''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"

(total-cost 1 5); => 5

'''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)"

;; Or we can add the third parameter to calculate the cost with 20% discount

(total-cost-with-discount 1 5 20); => 4

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

You can use the optional argument syntax seen above to implement variable numbers, but here's another way to do it by writing multiple functions with different arguments all in one.

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

;; Third case

(make-address "London" "Baker Street" 221 "B"); => "221 Baker Street, Apt. B, London"

'''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"

(make-mailing-label {:name "Her Majesty"

:address "Buckingham Palace, London"}); => "Her Majesty\nBuckingham Palace, London\nUK"

'''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))

fifty; => 50

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

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"

(discount-50pc 100); => 50

(discount-50pc 5); => 2.5

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

(calculate-discounted-price 100 "Bill"); => 50

(calculate-discounted-price 100 "Charlie"); => 100

You can pass functions as arguments to other functions

(defn format-price-uk [price]

(format-receipt "Toilet Paper" 5 format-price-us); => "Toilet Paper $5"

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

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

;; Calls add-store-name with the result of the format function

(add-store-name (format-receipt "Toilet Paper" 5 format-price-us)); => "Toilet Paper $5\n Thanks for shopping at Safeway"

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

;; Using built-in addition

(* 5 5); => 10

'''Distinguishing subroutines and functions'''

;; Functions without return values simply return nil

(no-return-value "hi"); => nil

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

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"

;; The original data structure is not changed

'''Is partial application possible and how'''

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

=={{header|CoffeeScript}}==

# Calling a function that requires no arguments

foo()

add2 1 #=> 3

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

;Calling a function that requires no arguments

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

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

(funcall (curry #'+ 1) 2)

=={{header|Cubescript}}==

// No arguments

myfunction

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

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

=={{header|D}}==

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

alias foo6b = partial!(foo6, 5);

assert(foo6b(6) == 11);

{{out}}

<pre>true

=={{header|Dart}}==

// Function definition

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

// Obtaining the return value of a function

var value = returnsValue();

=={{header|Delphi}}==

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;

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

* 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:

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 with named arguments:

Using a function in statement context:

if true {

foo()

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

var x = if foo() {

1

} else {

2

Obtaining the return value of a function:

var x = 2

Distinguishing built-in functions and user-defined functions:

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

func foo() { } //A user-defined function

print(isBuiltin(foo)) //Prints: false

Distinguishing subroutines and functions:

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

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)

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

# calling a function with no arguments:

random-int

# partial application is not possible, due to the fact that

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

=={{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") };

Calling a closure without arguments

c0();

Calling a closure with arguments

c2(2,4);

Passing arguments by reference:

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

var a := 1;

exch(ref a);

=={{header|Elixir}}==

# Anonymous function

end

end

=={{header|Erlang}}==

no_argument()

one_argument( Arg )

% Arguments are passed by reference, but you can not change them.

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

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

noArgs()

// Partial application example

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

* 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

"Hello there" >>subject

body >>body

* 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>:

=={{header|Forth}}==

a-function \ with a fixed number of arguents

a-function \ having optional arguments

: up ( n -- ) negate down ;

: right ( n -- ) 0 move ;

=={{header|Fortran}}==

===Examples===

implicit none

integer :: a

write(*,*) 'Output of subroutine: ', a

end subroutine

<pre>

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.

...

In this case, even if "DIST" happened to be the name of some library function, invocations within the routine defining it would not be of the library function.

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.

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.

WRITE (6,*) "Result=",INTG8(SIN, 0.0,8*ATAN(1.0),0.01)

WRITE (6,*) "Linear=",INTG8(TRIAL,0.0,1.0, 0.01)

This involves a fair amount of juggling special declarations so that the compiler will make the desired assumptions that a function is being called upon, rather than the value of some variable. This is eased somewhat with F90 onwards if the MODULE protocol is used so that at least you do not have to remember to declare INTG8 as REAL. Certain library functions are not allowed as candidates for passing to INTG8 (for instance, the compiler may render them as in-line code, bypassing the protocol used for functions) and arithmetic statement functions are usually rejected, as would be an array masquerading as a function. Arithmetic expressions are not allowable as possible "functions" either - how might something like <code>sin(x) + 3*sqrt(x) + 7</code> be recognised as a function instead? As <code>INTG8(SIN + 3*SQRT + 7,''etc...''</code>? Unlike Algol, Fortran does not offer the call-by-name facility as used in [[Jensen's_Device|Jensen's Device]], which would be something like <code>INTG8(SIN(X) + 3*SQRT(X) + 7,''etc...''</code> and would also require passing variable X. Perhaps a keyword BYNAME might be introduced one day. Until then a properly-named function must be declared and its name only be given. And of course, candidate functions must have the correct number and type of parameters, or else...

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

END TYPE MIXED

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

end

=={{header|FreeBASIC}}==

Sub Saludo()

Print "Hola mundo!"

?

testCadenas("1, 2, 3, 4, cadena, 6, 7, 8, \'incluye texto\'")

{{out}}

<pre>Hola mundo!

'''[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

Print "Hello world!"

Output:

<pre>

The following examples use functions from the standard packages

plus a few dummy local functions:

"image"

"image/gif"

func f() (int, float64) { return 0, 0 }

func g(int, float64) int { return 0 }

* 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

//h("fail", f())

// But this will:

* Calling with a variable number of arguments:

h("ex2", 1, 2)

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

h("ex4", list...)

// but again, not mixed with other arguments, this won't compile:

* Optional arguments and named arguments are not supported.

* Optional arguments are supported.

import "fmt"

func main() {

fmt.Println(doIt(Params{a: 1, c: 9})) // prt 10

* Named arguments are supported.

import "fmt"

args["c"] = 1

bar(args["a"], args["b"], args["c"]) // prt 3, 2, 1

* Within a statement context.

* In a first-class context:

if unicode.IsSpace(r) {

return -1

strings.Map(fn, "Spaces removed")

strings.Map(unicode.ToLower, "Test")

* Obtaining the value:

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

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

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

* Go has no subroutines, just functions and methods.

* Go arguments are passed by value.

::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"

fmt.Println("zeroptr:", i) // prt zeroptr: 0

fmt.Println("pointer:", &i) // prt pointer: 0xc0000140b8

* Partial and Currying is not directly supported.

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

import "fmt"

partial := partialSum(13)

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

=={{header|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")

* Calling a function with named arguments

* 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)

** Store functions in collections

** Use functions as arguments to other functions

** Use functions as return values of other functions

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

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

}

def func = funcMaker("a", 2, true)

* Obtaining the return value of a function

* Distinguishing built-in functions and user-defined functions

=={{header|Haskell}}==

-- Calling a function with a fixed number of arguments

multiply x y = x * y

-- Distinguishing subroutines and functions

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

=={{header|i}}==

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

end

}

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

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)

=={{header|J}}==

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

And a noun, in J, is an array.

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.