Function definition: Difference between revisions

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

Function definition:

Lambda function definition:

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

Linkage conventions are: register 1 : the parameter list, register 0 : the return value,

and register 14 : the return address.

USING DEFFUN,R13

SAVEAREA B PROLOG-SAVEAREA(R15)

Z DS F

YREGS

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

As with other low-level languages, 6502 assembler has subroutines rather than functions in the strict sense. This implementation of <tt>MULTIPLY</tt> behaves rather like a function, however: it expects two 'parameters' to be passed in the index registers <tt>X</tt> and <tt>Y</tt> and it returns the answer in the accumulator. Note that the 6502 has no <tt>MUL</tt> instruction, so multiplication is carried out by repeated addition.

TXA ; so use a memory address

MULLOOP: DEY

CPY #$01

BNE MULLOOP

An alternative implementation that multiplies A by X and checks if A/X is zero.

; Multiplies A by X

MAIN: LDA #50

LDX #5

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

What values are returned (if any) and where they are returned, will depend on the calling convention used. Code written by a C compiler will typically pass parameters onto the stack and use a "frame pointer" to reference them. For this simple example, the operands will be passed into the function using the registers <code>D0</code> and <code>D1</code>, and the output will be in <code>D0</code>. A function is called by using <code>JSR foo</code> where <code>foo</code> is a labeled section of code or a 24-bit memory address. Execution will continue along starting at that address, until an <code>RTS</code> is encountered, at which point the return address will be popped off the stack into the program counter.

MOVE.L D1,#$0400

MULU D0,D1

RTS

=={{header|8051 Assembly}}==

Like other assembly languages, 8051 doesn't have functions but instead has symbolic references to code. Function arguments are passed via registers decided on beforehand.

mov a, #100

mov b, #10

multiply:

mul ab

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

It's important to remember that, unlike other languages, execution of assembly code (and this is true for all assembly languages, not just the 8086) is on a purely linear path by default, much like in other "primitive" languages like BASIC, and so there is nothing stopping the instruction pointer from "falling into" subroutines. Often this can be handy if you're trying to code a variation on a function whose only difference is doing a few extra things at the beginning, but it's something you'll need to guard against, either with a return to the operating system or an infinite loop.

mov al, 0x04

mov bl, 0x05

multiply:

mul bl ;outputs 0x0014 to ax

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program functMul64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|ACL2}}==

=={{header|ActionScript}}==

return a * b;

=={{header|Ada}}==

and an implementation of:

begin

return A * B;

The Ada 2012 standard provides an even simpler way to define and implement functions:

Ada supports generic functions which can take generic formal parameters like the numeric type to use:

type Number is digits <>;

implemented as:

begin

return A * B;

To use this, you need to instantiate the function for each type e.g.

with Multiply;

...

type My_Integer is Range -100..100;

function Multiply_My_Integer is new Multiply(My_Integer);

=={{header|Aime}}==

multiply(real a, real b)

{

return a * b;

=={{header|ALGOL 60}}==

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

(

a * b

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

begin

a * b

=={{header|ALGOL-M}}==

This implementation takes two integers and returns an integer. Note that a function is distinguished from a procedure, which does not return a value.

INTEGER A, B;

BEGIN

MULTIPLY := A * B;

=={{header|AmigaE}}==

-> other statements if needed... here they are not

ENDPROC a*b -> return value

PROC main()

WriteF('\d\n', my_molt(10,20))

=={{header|AntLang}}==

Explicit definition has the syntax:

Inside functions, the variable args contains the sequence of arguments.

x, y and z contain the first, second and third argument.

=={{header|APL}}==

{{works with|GNU_APL}}

⍝⍝ APL2 'tradfn' (traditional function)

⍝⍝ This syntax works in all dialects including GNU APL and Dyalog.

⍝⍝ A 'dfn' or 'lambda' (anonymous function)

multiply ← {⍺×⍵}

{{works with|Dyalog_APL}}

⍝⍝ Dyalog dfn (lambda) syntax

multiply ← ×

Works on arrays of any rank (any number of dimensions): atoms, lists, tables, etc.

=={{header|AppleScript}}==

return a * b

A function in AppleScript is called a "handler". It can take one of three different forms, depending on what the scripter finds most convenient. Calls to it must match the form used in the handler definition. The above is an example of a handler with "positional" parameters. Either <code>to</code> or <code>on</code> may be used as the first word in the header line. When the script's compiled, the handler label is automatically appended to the <code>end</code> line too if it wasn't written in.

return a * b

end multiply

AppleScript also offers handlers with "labeled" [sic] parameters. These aren't used much now as the limited choice of label enums makes it difficult to choose ones that make sense in English, although it's just about possible here:

return a * b

end multiplication

Labeled parameters don't need to be in the same order in the calls as in the handler definition, but <code>of</code>, if used, is regarded as a direct parameter and requires some parenthesis if it's not given first or if the context isn't entirely clear.

For the past few years, handlers with "interleaved" parameters have also been possible. They're a development from AppleScriptObjectiveC and coders can specify their own labels provided these aren't reserved words. Calls to these handlers must reference the handlers' "owners", which are usually represented within the same script by the keyword <code>my</code>. The parameter order is the same in the calls as in the handler definitions:

return a * b

end multiply:|by|:

=={{header|Applesoft BASIC}}==

Function names in Applesoft BASIC can be longer than two characters but only the first two characters are significant. Function names cannot contain any keywords.

=={{header|Argile}}==

with a macro and a variable number of parameters:

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program functMul.s */

=={{header|ArnoldC}}==

I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE a

I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE b

ENOUGH TALK

I'LL BE BACK product

=={{header|Arturo}}==

print multiply 3 7

print multiply2 3 7

{{out}}

=={{header|AutoHotkey}}==

multiply(multiplicand, multiplier) {

Return (multiplicand * multiplier)

=={{header|AutoIt}}==

$I=11

$J=12

Func product($a,$b)

Return $a * $b

=={{header|AWK}}==

{

return a*b

BEGIN {

print multiply(5, 6)

=={{header|Axe}}==

r₁*r₂

=={{header|BASIC}}==

{{works with|QBasic}}

FUNCTION multiply% (a AS INTEGER, b AS INTEGER)

multiply = a * b

==={{header|BASIC256}}===

return a * b

==={{header|Commodore BASIC}}===

In Commodore BASIC function definition can consist of any mathematical operation other functions or commands which result in a numeric expression. The definition is limited to single statement, and it accepts only a single argument. When using the function, keyword fn must precede the function name, which itself must be uniquely distinguishable by its first two characters.

20 Y = 4 : REM VALUE OF SECOND ARGUMENT MUST BE ASSIGNED SEPARATELY

==={{header|IS-BASIC}}===

==={{header|GWBASIC}}===

{{works with|BASICA}}

20 PRINT FNMULT(5,6)

39 END

==={{header|OxygenBasic}}===

'SHORT FORMS:

float multiply(float a,b) = a * b

'TEST:

print multiply(pi,2) '6.28...

==={{header|QBasic}}===

'(as they are implicitly convertible to Double)

FUNCTION multiply# (a AS DOUBLE, b AS DOUBLE)

PRINT multiply(3, 1.23456)

{{out}}

<pre> 3.703680038452148</pre>

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

The <code>FUNCTION</code> and <code>DEF</code> commands are synonymous and can be interchanged.

LET multiply = a * b

END FUNCTION

DEF multiply (a, b) = a * b

==={{header|uBasic/4tH}}===

End

==={{header|Yabasic}}===

return a * b

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

Windows batch files only have procedures, not functions. Instead, environmental variables can be used as a global shared state.

SET /A result = 0

CALL :multiply 2 3

GOTO :eof

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

Single-line function:

END

Multiline function:

LOCAL c

c = a * b

=={{header|bc}}==

{{Works with|GNU bc}}

=={{header|BCPL}}==

A function is simply defined as an expression in terms of its arguments.

Defining a block of code that executes some statements and then returns a

to define a function containing imperative statements. When used this way,

it is equivalent to the functions in most other imperative languages.

$( // any imperative statements could go here

resultis a * b

=={{header|BlitzMax}}==

return a*b

end function

{{out}}<pre>5.08310890</pre>

=={{header|Boo}}==

return x * y

=={{header|BQN}}==

Tacit definition:

With names:

=={{header|Bracmat}}==

=={{header|Brat}}==

=={{header|C}}==

{

return a * b;

===Macros===

Macros can be defined at the top of a program and the compiler will replace the function calls with the function itself before compiling the program (the source file will not change).

Parentheses should be added around parameters in the function definition to avoid order of operations errors when someone uses the macro as such:

A program with that call would be compiled as if this were coded instead:

Another advantage of macros is that they work with all types alike. For example, the above macro can be used both to multiply double values (like the function above), and to multiply int values (giving an int, which the function doesn't).

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

{

return a * b;

Anonymous function:

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

An inline function differs from the normal function by the keyword inline and the fact that it has to be included in every translation unit which uses it (i.e. it normally is written directly in the header). It allows the compiler to eliminate the function without having the disadvantages of macros (like unintended double evaluation and not respecting scope), because the substitution doesn't happen at source level, but during compilation. An inline version of the above function is:

{

return a*b;

If not only doubles, but numbers of arbitrary types are to be multiplied, a function template can be used:

Number multiply(Number a, Number b)

{

return a*b;

Of course, both inline and template may be combined (the <tt>inline</tt> then has to follow the <tt>template&lt;...&gt;</tt>), but since templates have to be in the header anyway (while the standard allows them to be compiled separately using the keyword <tt>export</tt>, almost no compiler implements that), the compiler usually can inline the template even without the keyword.

Since C++20, the template parameters can be inferred using <tt>auto</tt>:

{

return a*b;

=={{header|ChucK}}==

fun float multiply (float a, float b)

{

// uncomment next line and change values to test

//<<< multiply(16,4) >>>;

=={{header|Clay}}==

=={{header|Clojure}}==

(* x y))

Or with multiple arities (in the manner of the actual <tt>*</tt> function):

([] 1)

([x] x)

(reduce * (* x y) more)))

=={{header|CLU}}==

The following is a function that multiplies two integers and ignores any error conditions

(as most examples do).

return(a * b)

The following is a type-parameterized function that wraps the built-in multiplication operator

It also shows the complete syntax of a function definition (type parameterization,

signals, and a <code>where</code> clause).

signals (overflow, underflow)

where T has mul: proctype (T, T) returns (T)

signals (overflow, underflow)

return(a * b) resignal overflow, underflow

=={{header|COBOL}}==

In COBOL, ''multiply'' is a reserved word, so the requirements must be relaxed to allow a different function name. The following uses a program:

{{works with|OpenCOBOL}}

PROGRAM-ID. myTest.

DATA DIVISION.

MULTIPLY x BY y GIVING z.

EXIT PROGRAM.

This example uses user-defined functions, which were added in COBOL 2002.

{{works with|GNU Cobol|2.0}}

PROGRAM-ID. myTest.

ENVIRONMENT DIVISION.

MULTIPLY x BY y GIVING z.

EXIT FUNCTION.

=={{header|Coco}}==

As CoffeeScript. In addition, Coco provides some syntactic sugar for accessing the <code>arguments</code> array reminiscent of Perl's <code>@_</code>:

Furthermore, when no parameter list is defined, the first argument is available as <code>it</code>:

=={{header|CoffeeScript}}==

=={{header|ColdFusion}}==

<cfargument name="a" type="numeric">

<cfargument name="b" type="numeric">

<cfreturn a * b>

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

===Ordinary Functions===

Ordinary functions operate on the values of argument expressions. Lisp functions terminate by returning one or more values, or by executing a non-local dynamic control transfer, in which case values are not returned.

(* a b))

====User-Defined Compiler Optimization of Functions====

In Lisp we can express optimizations of calls to a function using compiler macros. For instance, suppose we know that the multiply function, which may be in another module, simply multiplies numbers together. We can replace a call to multiply by a constant, if the arguments are constant expressions. Like the usual kind of Lisp macro, the compiler macro takes the argument forms as arguments, not the argument values. The special keyword &whole gives the macro access to the entire expression, which is convenient for the unhandled cases, whereby no transformation takes place:

(if (and (constantp a) (constantp b))

(* (eval a) (eval b))

Lisp implementations do not have to honor compiler macros. Usually compilers make use of them, but evaluators do not.

Also, the DEFGENERIC is optional, since the first DEFMETHOD will define the generic function, but good practice.

;;; terrific example coming

=={{header|Cowgol}}==

rslt := a * b;

=={{header|Creative Basic}}==

DECLARE Multiply(N1:INT,N2:INT)

'Can also be written with no code in the subroutine and just RETURN N1*N2.

=={{header|D}}==

int multiply1(int a, int b) {

return a * b;

import std.stdio;

writeln("2 * 3 = ", result);

Both the compile-time and run-time output:

<pre>6

=={{header|Dart}}==

print(multiply(1,2));

print(multiply2(1,2));

return num1 * num2;

}

=={{header|dc}}==

For dc, the functions (called macros) are limited to names from 'a' to 'z'

Create a function called 'm'

Use it (lm loads the function in 'm',x executes it, f shows the the stack.)

=={{header|Delphi}}==

In addition to what is shown in the section [[#Pascal|Pascal]], the following is possible too:

begin

result := a * b;

=={{header|Diego}}==

with_funct[]_calc([a]*[b]);

end_funct[];

=={{header|Draco}}==

return type of the function.

a * b

=={{header|Dragon}}==

return a*b

=={{header|DWScript}}==

begin

Result := a * b;

=={{header|Dyalect}}==

a * b

Using lambda syntax:

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

=={{header|E}}==

return a * b

(This does not necessarily return a product, but whatever the "multiply" method of <var>a</var> returns. The parameters could be guarded to only accept standard numbers.)

It is also possible to write short anonymous function definitions which do not need explicit returns:

This definition is identical to the previous except that the function object will not know its own name.

=={{header|EasyLang}}==

r = a * b

.

call multiply 7 5 res

=={{header|EchoLisp}}==

(define (multiply a b) (* a b)) → multiply ;; (1)

(multiply 1/3 666) → 222

multiply → (λ (_a _b) (#🔶_multiply)) ;; compiled function

=={{header|Efene}}==

A * B

}

run = fn () {

io.format("~p~n", [multiply(2, 5)])

=={{header|Eiffel}}==

multiply(a, b: INTEGER): INTEGER

do

Result := a*b

end

=={{header|Ela}}==

Anonymous function:

=={{header|Elena}}==

Anonymous function / closure:

Root closure:

=={{header|Elixir}}==

def multiply(x,y) do

x * y

end

{{out}}

=={{header|Elm}}==

--There are multiple ways to create a function in Elm

--This is an anonymous function

\x y -> x*y

=={{header|Emacs Lisp}}==

A "docstring" can be added as follows. This is shown by the Emacs help system and is good for human users. It has no effect on execution.

"Return the product of X and Y."

=={{header|Erlang}}==

===Using case, multiple lines===

-module(func_definition).

-export([main/0]).

case {A,B} of

{A, B} -> A * B

{{out}}

<pre>12

</pre>

===In a single line===

-module(func_definition).

-export([main/0]).

io :format("~p~n",[K]).

The output is the same.

=={{header|Euphoria}}==

return a * b

If you declare the arguments as <code>object</code> then sequence comprehension kicks in:

return a * b

end function

? multiply( a, b )

? multiply( a, 7 )

{{out}}

<pre>81

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

The default will be an integer function but you can specify other types as shown:

=={{header|Factor}}==

=={{header|Falcon}}==

> "Hi ", name

=={{header|FALSE}}==

m: {binding the function to one of the 26 available symbol names}

=={{header|Fantom}}==

{

public static Void main ()

echo ("Multiply 2 and 4: ${multiply(2, 4)}")

}

=={{header|Fermat}}==

=={{header|Fexl}}==

Or if I'm being cheeky:

=={{header|Fish}}==

Functions cannot be named in Fish. However, they can be defined as new stacks that pull a certain number of arguments off the stack that came before. <code>2[</code> says pull 2 values off the stack and put them in a new, separate stack. <code>]</code> says put all remaining values in the current stack onto the top of the stack below (the old stack).

=={{header|Forth}}==

=={{header|Fortran}}==

In FORTRAN I (1957), inline function could be defined at the beginning of the program. Let's note than to specify a floating point real the name of the statement function begins with an X (no type declaration) and to specify this is a function the name ends with a F.

And for interger multiplication:

In FORTRAN IV, FORTRAN 66 or later, define a function:

REAL MULTIPLY, X, Y

MULTIPLY = X * Y

And for integer multiplication:

INTEGER MULTINT, X, Y

MULTINT = X * Y

In Fortran 95 or later, define an elemental function, so that this function can be applied to whole arrays as well as to scalar variables:

contains

elemental function multiply(x, y)

multiply = x * y

end function multiply

use elemFunc

z = multiply(x,y) ! element-wise invocation only works with elemental function

It is worth noting that Fortran can call functions (and subroutines) using named arguments; e.g. we can call multiply in the following way:

(Because of commutativity property of the multiplication, the difference between <code>multiply(x,y)</code> and <code>multiply(y,x)</code> is not evident)

Also note that the function result can be declared with a different name within the routine:

contains

elemental function multiply(x, y) result(z)

z = x * y

end function multiply

=={{header|FreeBASIC}}==

Function multiply(d1 As Double, d2 As Double) As Double

Return d1 * d2

This function could either be used for all numeric types (as they are implicitly convertible to Double)

or could be overloaded to deal with each such type (there are 12 of them).

Alternatively, one could write a macro though this wouldn't be type-safe:

=={{header|Free Pascal}}==

Furthermore, after the assignment to the return variable further statements may follow.

To ensure a value is returned immediately and no further following statements are processed, using the built-in <tt>exit</tt> procedure is possible too in <tt>{$mode objFPC}</tt>:

begin

exit(a * b);

If <tt>exit</tt> has been redefined in the current scope, its special meaning can be accessed via the fully-qualified identifier <tt>system.exit</tt>.

Note, any enclosing <tt>finally</tt> frames of <tt>try … finally … end</tt> are processed first before actually returning from the <tt>function</tt>.

=={{header|Frink}}==

This function works correctly with any combination of arbitrarily-large integers, arbitrary-precision floating point numbers, arbitrary-size rational numbers, complex numbers, intervals of real numbers, and even numbers with units of measure (e.g. <code>multiply[1 watt, 1 s]</code> gives an answer with dimensions of energy. Frink tries hard to always Do The Right Thing with math and numerics and units of measure.

=={{header|Futhark}}==

let multiply (x: i32, y: i32) : i32 = x * y

=={{header|FutureBasic}}==

local fn multiply( a as long, b as long ) as long

print fn multiply( 3, 9 )

Output:

<pre>

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=bc93236474d9937217dd4117026f7441 Click this link to run this code]'''

Print Multiply(56, 4.66)

Return f1 * f2

Output:

<pre>

=={{header|GAP}}==

return a*b;

=={{header|GML}}==

In GML one can not define a function but in [[Game Maker]] there is a ''script'' resource, which is the equivalent of a function as defined here. Scripts can be exported to or imported from a text file with the following format:

a = argument0

b = argument1

=={{header|Gnuplot}}==

# then for example

=={{header|Go}}==

The return statement can contain an expression of the function return type:

return a * b

Alternatively, if the return value is named, the return statement does not require an expression:

z = a * b

return

=={{header|Golfscript}}==

=={{header|Groovy}}==

Test Program:

{{out}}

<pre>x * y = 20 * 50 = 1000</pre>

=={{header|Halon}}==

{

return $a * $b;

=={{header|Haskell}}==

Alternatively, with help of auto-currying,

You can use [[lambda-function]]

=={{header|Haxe}}==

return x * y;

=={{header|hexiscript}}==

return a * b

=={{header|HicEst}}==

multiply = a * b

=={{header|HolyC}}==

return a * b;

}

F64 x;

x = Multiply(42, 13.37);

=={{header|Hy}}==

Function definition: