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.

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.

 

* 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

}

int myMethod(int a){

return f(a, 1.414);

 

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.

 

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

 

To avoid ambiguity, only the last argument to a function can have varargs.

* Calling a function with named arguments

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

return

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

+ ((Integer)params.get("y")).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

 

* Is partial application possible and how

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

 

Neither optional (see above) nor named arguments are supported, though the latter (and the inverse of the former) may be simulated with the use of a helper object to be queried for the existence and/or values of relevant keys. <span style="color: transparent;">Seriously, what is "statement context"?</span>

 

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 }

};

var add42 = make_adder(42);

 

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

 

=={{header|jq}}==

 

=={{header|Julia}}==

# Calling a function that requires no arguments:

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

v = [4, 6, 8]

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

 

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

println(fun7(11)) // calling function with a return type of Double (here explicit but can be implicit)

println(fun8("Hello")("world")) // partial application isn't supported though you can do this

 

{{out}}

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

 

 

 

=== parentheses ===

 

 

=== unbounded lists ===

 

# unbounded lists on writeln and join

 

# unbounded list on writeln

 

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

0,

split ZLS, .code,

)

 

...

}

 

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

foo 1. ; (5) Equivalent to (4)

foo (bar). ; (6) Parentheses necessary here since bar is not a literal

 

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.

 

 

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

 

All three of the above procedures will act the same.

 

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!

ok

 

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

ok

 

'''Calling a function with optional arguments or calling a function with a variable number of arguments:'''

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

(defun my-func (a b c)

(: io format '"~p ~p ~p~n" (list a b c)))

 

Here is some example usage:

> (slurp '"args.lfe")

#(ok args)

> (my-func '"apple" '"banana" '"cranberry" '"bad arg")

exception error: #(unbound_func #(my-func 4))

 

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

 

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

...

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

((/= count limit) (keep-going-func count)))

...

 

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

 

From the LFE REPL:

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

true

 

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

 

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

...)

 

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

 

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

'Call a function - Liberty BASIC

 

'Is partial application possible and how

'impossible

 

=={{header|Lingo}}==

 

*Calling a function that requires no arguments

-- or alternatively:

 

*Calling a function with a fixed number of arguments

-- or alternatively:

 

*Calling a function with optional arguments

if voidP(b) then b = 1

return a * b

-- 46

put foo(23)

 

*Calling a function with a variable number of arguments

res = 0

repeat with i = 1 to the paramCount

end repeat

return res

 

*Calling a function with named arguments

*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

on doubleInt (n)

return n*2

put map(l, #doubleInt)

 

*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

end repeat

return res

 

*Distinguishing subroutines and functions

*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

someList[i] = someList[i] * 2

end repeat

double(l)

put l

double(l.duplicate())

put l

 

=={{header|Little}}==

local fuctions.

 

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

foo();

puts (a);

puts (b);

 

=={{header|Lua}}==

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

fixed() --> nil nil nil

-- There is no separate notion of subroutines

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

 

=={{header|Luck}}==

f();;

 

 

/* Is partial application possible and how */

 

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

 

=={{header|Maple}}==

Distinguishing built-in functions and user-defined functions:

true

Distinguishing subroutines and functions: There is no distinction.

 

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

 

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

 

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

% Calling a function that requires no arguments

function a=foo();

% Stating whether arguments are passed by value or by reference

% 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.

 

=={{header|Nanoquery}}==

no_args()

 

catch

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

 

=={{header|Nemerle}}==

f()

 

def h = f(_, 2)

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

 

=={{header|Nim}}==

Translated from Python, when possible:

discard

# call

let x = return_something(19) + 10

let y = 19.return_something() + 10

 

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

 

 

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

 

 

* Calling a function with a variable number of arguments:

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

 

 

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

 

 

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

 

* Distinguishing built-in functions and user-defined functions:

 

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)

 

are the same call to function f and the interpreter will translate all of them into the first one. Which parameters are really used by f will depend on f implementation.

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

 

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

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

 

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

{{out}}

<pre>H:\>rexx fdate

 

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

call(Str, ["gg", 1, "hh"]) \\ variable number of arguments in a vector

(x->x^2)(3); \\ first-class

 

Built-in functions are like user-defined functions in current versions. In older versions built-in functions cannot be passed as closures.

 

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

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

 

=={{header|Phix}}==

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

 

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

<span style="color: #0000FF;">{<span style="color: #000000;">cities<span style="color: #0000FF;">,<span style="color: #0000FF;">{<span style="color: #0000FF;">}<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[2]</span>

<span style="color: #0000FF;">{<span style="color: #000000;">cities<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;">-- ""

* Calling a function with no parameters still requires the "()" empty argument list.

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

<span style="color: #0000FF;">?<span style="color: #000000;">myfunction<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- displays {1,"default"}</span>

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

 

* Sequence parameters can be of any length, which is another way to implement optional/variable number of arguments.

* 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

 

* The programmer is free to use either positional parameters or named parameters, or a mixture of both (with positional parameters first).

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

<span style="color: #0000FF;">?<span style="color: #7060A8;">call_func<span style="color: #0000FF;">(<span style="color: #000000;">first_class<span style="color: #0000FF;">,<span style="color: #0000FF;">{<span style="color: #000000;">1<span style="color: #0000FF;">}<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- ""</span>

<span style="color: #0000FF;">?<span style="color: #000000;">first_class<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- ""

 

The value of r_my_func can be passed as an argument to any routine, or stored in a table, and invoked in a similar fashion.<br>

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

 

* 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

saludo

 

 

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

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

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

 

Input()

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

 

 

{{works with|QuickBasic|4.5}}

{{trans|FreeBASIC}}

DIM nuevaCadena$

CALL testNumeros(1, 2, 0)

PRINT

{{out}}

<pre>

=={{header|R}}==

Translated from Python, when possible.

no_args <- function() NULL

no_args()

 

### Is partial application possible and how

 

=={{header|Racket}}==

 

#lang racket

 

(curry foo 1 2) ; later apply this on 3

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

 

=={{header|Raku}}==

Calling a function that requires no arguments:

 

foo() # as function

foo.() # as function, explicit postfix form

&foo() # as object invocation

&foo.() # as object invocation, explicit postfix

 

Calling a function with exactly one argument:

 

foo(1) # as named function

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

1.foo() # as method via dispatcher

1."$name"() # as method via dispatcher, symbolic

 

Method calls are included here because they do eventually dispatch to a true

Calling a function with exactly two arguments:

 

foo(1,2) # as named function

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

1.foo(2) # as method via dispatcher

1."$name"(2) # as method via dispatcher, symbolic

 

Optional arguments don't look any different from normal arguments.

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

 

foo(@args) # as named function

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

1.foo(@args) # as method via dispatcher

1."$name"(@args) # as method via dispatcher, symbolic

Note: whether a function may actually be called with a variable number of arguments depends entirely

on whether a signature accepts a list at that position in the argument list, but

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:

 

 

Calling a function with named arguments:

 

 

...and so on. Operators may also be called with named arguments, but only

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;

 

f(|@args); # 45 equivalent to f(1,2,3)

 

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

 

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

errmsg= '***error***' /*an error message eyecatcher string. */

if arg() \== 0 then say errmsg "the YEARFUNC function won't accept arguments."

 

 

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

║ ║

end

 

 

 

║ Calling a function with optional arguments. ║

║ ║

end /*j*/

 

 

 

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

║ ║

call value 'COMMON.'name,val

end

 

 

║ Calling a function in statement context. ║

║ ║

yr= yearFunc() + 20

say 'two decades from now, the year will be:' yr

 

 

║ Obtaining the return value of a function. ║

║ ║

 

call yearFunc

 

 

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

║ ║

 

date: return 4 /*Bob only "went out" 4 times, no need */

 

 

║ Distinguishing subroutines and functions. ║

║ ║

║ are: map (f 1 9) [1..9] ║

║ or: map (f(1,_,9)) [1, ..., 9] ║

 

===version 2===

* 29.07.2013 Walter Pachl trying to address the task concisely

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

If sigl=39 Then

Say 'fb cannot be invoked as function (it does not return a value'

{{out}}

<pre>

 

=={{header|Ring}}==

hello()

func hello

see "Hello from function" + nl

first() second()

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

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

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

func sum x,y see x+y+nl

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

See "Hello World!" + nl

func main

see "Message from the main function" + nl

 

=={{header|Ruby}}==

 

*Calling a function that requires no arguments

 

foo #=> "foo"

 

*Calling a function with a fixed number of arguments

 

foo(1) #=> 1

foo "1" #=> "1"

 

*Calling a function with optional arguments

 

foo #=> [0, 0, true]

foo(1) #=> [1, 1, true]

foo(1,2) #=> [1, 2, true]

 

*Calling a function with a variable number of arguments

 

foo #=> []

 

*Calling a function with named arguments

 

 

*Using a function in statement context

 

*Obtaining the return value of a function

 

bar = foo 10,20

x,y = sum_and_product(3,5)

p x #=> 8

 

*Distinguishing built-in functions and user-defined functions

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

 

raise "Error input" # Kernel#raise

Integer("123") # Kernel#Integer

private # Module#private

require # Kernel#require

 

*Stating whether arguments are passed by value or by reference

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

p ary.sum #=> 15

p ary.sum(''){|n| (-n).to_s} #=> "-1-2-3-4-5"

 

:Splat operator:

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

 

args = [1,2,3]

foo *args #=> [1, 2, 3]

args = [1,2]

 

:Syntax sugar:

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

i = 3

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

p a & [4,2] #=> [2] a.&([4,2])

p "abcde"[1..3] #=> "bcd" "abcde".[](1..3)

::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() {}

 

 

 

=={{header|Scala}}==

{{libheader|Scala}}

def myFunction0() = ???

myFunction0() // function invoked with empty parameter list

 

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

 

=={{header|Seed7}}==

* All parameters are positional.

 

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

 

 

result

var integer: sum is 0;

 

s := sum([] (1, 2, 3)); # Use an aggregate to generate an array.

 

 

 

 

=={{header|SenseTalk}}==

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

 

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

put "This function was run with zero arguments."

return "Return value from zero argument function"

 

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

put "2 argument function: arg1 = " & arg1 & "; arg2 = " & arg2

put "Parameters = " & the parameterList

 

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

 

function ThreeArgFn arg1, arg2, arg3

put "3 argument function: arg1 = " & arg1 & "; arg2 = " & arg2 & "; arg3 = " & 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

 

end if

put "One argument function; arg1 = " & arg1

 

* 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

function AddOne n

add 1 to n

 

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

// Prints: 1 - 2 - 3

 

to handle CustomHandler arg1, arg2, arg3

put arg1 && "-" && arg2 && "-" && arg3

 

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

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

 

...

end MyCommand

 

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

...

end MyFn

...

end args

 

=={{header|Sidef}}==

All functions in Sidef are first-class closures

foo(1, 2); # with two arguments

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

 

var arr = [1,2,3];

 

Partial application is possible by using a curry function:

 

func (*args2) {

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

 

var adder = curry(add, 1);

 

=={{header|Smalltalk}}==

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

 

=={{header|SSEM}}==

 

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

 

=={{header|Swift}}==

noArgs()

 

 

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

 

=={{header|Tcl}}==

aCallToACommandWithOne argument

aCallToACommandWith arbitrarily many arguments

aCallToACommandWith -oneNamed argument -andAnother namedArgument

aCallToACommandWith theNameOfAnotherCommand

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

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$

PRINT

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

{{out}}

<pre>

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:

 

 

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

End Sub

<pre>no arguments ok

no arguments ok

 

=={{header|WDTE}}==

noargs -- print;

 

# evaluates `+ 3` and then passes 7 to the resulting partially applied

# function.

 

=={{header|WebAssembly}}==

 

 

(local $result i32)

(i32.const 8)

)

 

=={{header|Wren}}==

Here are some examples:

 

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

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

mc1.x = 42 // change mc1's field using setter

System.print(-mc1.x) // invoke prefix operator -

 

{{out}}

 

=={{header|XLISP}}==

(foo)

 

; or it can simply be discarded

(foo bar)

 

=={{header|XSLT}}==

 

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

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

</xsl:template>

</xsl:stylesheet>

 

=={{header|Yabasic}}==

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

 

 

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

 

=={{header|zkl}}==

 

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)

s:=f()

fcn{}.isType(self.fcn) //True

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

 

=={{header|zonnon}}==

module CallingProcs;

type

writeln(total);

end CallingProcs.

 

=={{header|Z80 Assembly}}==

 

* Functions that take a fixed number of arguments usually require the programmer to load the arguments into registers or push them to the stack prior to calling the function.

;input: B = top nibble, C = bottom nibble. Outputs to accumulator.

;usage: B = &0X, C = &0Y, => A = &XY

RLCA

OR C

 

* Assembly language in general has difficulty with optional and variable numbers of arguments (unless it is written by a compiler, of course). Prior to the function call, an optional argument would most likely be set to zero if intended to be unused in a particular instance of a function.

* Getting a function's return value depends on how it was programmed. The concept of "return values" is a high-level construct that isn't enforced by assembly languages in general, and Z80 is no exception. The programmer is free to choose which register or section of memory the return value of a function is stored, if one even exists. Generally speaking the accumulator is usually used for this purpose but it depends on the data type as well as the needs of the program.

 

;input registers: A,B. Outputs to A.

ADD a,b

 

* Some implementations of Z80 Assembly have built-in functions. These are essentially just subroutines located in ROM at a specific memory address. Functions stored in low memory can be called with the <code>RST #</code> instruction. Anything in high memory will need to be <code>CALL</code>ed like any other user-created subroutine. On the Amstrad CPC, <code>CALL &BB5A</code> will print the accumulator to the screen as an ASCII character.

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

100 PRINT SIN(50): REM here we pass a parameter to a builtin function

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

 

{{omit from|GUISS}}