Function definition: Difference between revisions

 

 

(Argument types should be chosen so as not to distract from showing how functions are created and values returned).

 

 

=={{header|ActionScript}}==

return a * b;

 

=={{header|Ada}}==

and an implementation of:

begin

return A * B;

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;

 

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

(

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

 

 

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

 

=={{header|AppleScript}}==

return a * b

 

=={{header|Argile}}==

with a macro and a variable number of parameters:

 

 

 

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 {

 

=={{header|BASIC}}==

{{works with|QBasic}}

 

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

multiply = a * b

 

 

 

 

 

 

 

 

 

 

 

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

C++ functions basically are the same as in C. Also macros exist, however they are discouraged in C++ in favour of inline functions and function templates.

 

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.

 

=={{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|Common Lisp}}==

(* a b))

 

 

=={{header|D}}==

return a * b;

return a * b;

 

 

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

begin

 

 

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:

 

 

 

 

A * B

}

run = fn () {

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

 

 

=={{header|Ela}}==

Anonymous function:

 

 

 

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

<pre>81

9.869587728

{7,14,21,28}

{51.9782,62.37384,72.76948,83.16512}</pre>

 

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

multiply := |Int a, Int b -> Int| { a * b }

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

 

=={{header|Forth}}==

 

=={{header|Fortran}}==

REAL MULTIPLY, X, Y

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

 

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

return a * b

 

=={{header|Golfscript}}==

 

=={{header|Groovy}}==

Test Program:

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

 

=={{header|Haskell}}==

 

=={{header|Haxe}}==

return x * y;

 

=={{header|HicEst}}==

multiply = a * b

 

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

return a * b

 

=={{header|IDL}}==

The task description is unclear on what to do when the arguments to the function are non-scalar, so here's multiple versions:

return, a* b

If "a" and "b" are scalar, this will return a scalar. If they are arrays of the same dimensions, the result is an array of the same dimensions where each element is the product of the corresponding elements in "a" and "b".

 

Alternatively, there's this possibility:

return, product([a, b])

This will yield the same result for scalars, but if "a" and "b" are arrays it will return the product of all the elements in both arrays.

 

Finally, there's this option:

return, a # b

This will return a scalar if given scalars, if given one- or two-dimensional arrays it will return the matrix-product of these arrays. E.g. if given two three-element one-dimensional arrays (i.e. vectors), this will return a 3x3 matrix.

 

=={{header|Inform 7}}==

 

=={{header|Io}}==

 

=={{header|J}}==

Works on conforming arrays of any rank (any number of dimensions, as long as the dimensions of one are a prefix of the dimensions of the other): atoms, lists, tables, etc.

 

Or, more verbosely (and a bit slower, though the speed difference should be unnoticeable in most contexts):

x * y

Here we use an [http://www.jsoftware.com/help/dictionary/intro18.htm explicit] definition (where the arguments are named) rather than a [http://www.jsoftware.com/help/dictionary/intro19.htm tacit] version (where the arguments are implied). In explicit J verbs, x is the left argument and y is the right argument.

 

=={{header|Java}}==

There are no global functions in Java. The equivalent is to define static methods in a class (here invoked as "Math.multiply(a,b)"). Overloading allows us to define the method for multiple types.

{

public static int multiply( int a, int b) { return a*b; }

public static double multiply(double a, double b) { return a*b; }

 

=={{header|JavaScript}}==

 

=={{header|Joy}}==

 

 

 

 

 

 

=={{header|Logo}}==

output :x * :y

=={{header|LSE64}}==

 

=={{header|Lua}}==

return a * b

 

=={{header|Lucid}}==

 

=={{header|M4}}==

 

 

 

B=1

 

multiply:

Invoking it

Using gmake, the define syntax is used to define a new function

B=1

 

@$(call multiply, $(A), $(B))

 

 

 

=={{header|MAXScript}}==

(

a * b

 

 

Metafont has macros, rather than functions; through those the language can be expanded. According to the kind of macro we are going to define, Metafont has different ways of doing it. The one suitable for this task is called <code>primarydef</code>.

 

 

 

 

 

 

=={{header|Modula-2}}==

BEGIN

RETURN a * b

 

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

BEGIN

RETURN a * b;

 

=={{header|MUMPS}}==

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols binary

 

 

product = multiplicand * multiplier

Area of a circle 10 yds radius: 314.159 sq. yds

10 yds = 9.144 metres

 

=={{header|NewLISP}}==

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

> (my-multiply 2 3)

 

=={{header|Nial}}==

Using variables

Using it

Point free form

Using it

Nial also allows creation of operators

Using it.

=6

|multiply 2 3

Since this is an array programming language, any parameters can be arrays too

=3 6

|mul [1,2] [10,20]

 

Here is the same function but with the use of the `return` keyword.

 

 

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

Oberon-2 uses procedures, and has a special procedure called a "Function Procedure" used to return a value.

BEGIN

RETURN a * b;

 

=={{header|Objeck}}==

return a * b;

 

=={{header|OCaml}}==

 

 

r = a .* b;

 

=={{header|OpenEdge/Progress}}==

return a * b .

 

=={{header|Oz}}==

X * Y

Or by exploiting first-class functions:

 

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

or

Note that in both cases the <code>;</code> is part of the definition of the function, not of the function itself: it suppresses the output of the function body, but does not suppress the output of the function when called. To do that, either double the semicolon (which will suppress the output of both) or wrap in braces:

 

=={{header|Pascal}}==

begin

 

=={{header|Perl}}==

The most basic form:

or simply:

Arguments in Perl subroutines are passed in the <code>@_</code> array, and they can be accessed directly, first one as <code>$_[0]</code>, second one as <code>$_[1]</code>, etc. When the above function is called with only one or no arguments then the missing ones have an undefined value which is converted to 0 in multiplication.

 

This is an example using [http://perldoc.perl.org/perlsub.html#Prototypes subroutine prototypes]:

{

my ($a, $b) = @_;

return $a * $b;

The above subroutine can only be called with exactly two [http://perldoc.perl.org/perldata.html#Scalar-values scalar values] (two dollar signs in the signature) but those values may be not numbers or not even defined. The <code>@_</code> array is unpacked into <code>$a</code> and <code>$b</code> lexical variables, which are used later.

 

sub multiply ($x, $y) {

return $x * $y;

 

 

 

 

 

=={{header|PHP}}==

{

return $a * $b;

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

return a * b;

 

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

declare (a, b) float;

return (a*b);

 

=={{header|PL/SQL}}==

IS

v_product NUMBER;

v_product := p_arg1 * p_arg2;

RETURN v_product;

 

 

a * b

 

=={{header|PostScript}}==

Inbuilt:

Function would be:

 

=={{header|PowerShell}}==

The most basic variant of function definition would be the kind which uses positional parameters and therefore doesn't need to declare much:

return $args[0] * $args[1]

Also, the return statement can be omitted in many cases in PowerShell, since every value that "drops" out of a function can be used as a "return value":

$args[0] * $args[1]

Furthermore, the function arguments can be stated and named explicitly:

return $a * $b

There is also an alternative style for declaring parameters. The choice is mostly a matter of personal preference:

param ($a, $b)

return $a * $b

And the arguments can have an explicit type:

return $a * $b

 

 

 

 

def __call__(self, a, b):

 

 

=={{header|Q}}==

or

or

Using it

 

 

a*b

# or:

# return(a*b)

 

 

 

 

 

 

 

=={{header|REBOL}}==

REBOL actually already has a function called 'multiply', which is a native compiled function. However, since it's not protected, I can easily override it:

 

=={{header|Retro}}==

 

=={{header|REXX}}==

 

=={{header|RLaB}}==

function

>> type(sin)

Functions are a data class on their own, or they can be member of a list (associative array).

 

1. user function specified from built-in functions, here basic addition

{

return x + y;

function

>> type(f)

 

2. function can be member of a list (associative array)

somelist.f = function(x, y)

{

rval = x + y;

return rval;

 

{

global(somelist);

rval = x * somelist.f(x, 2*y);

return rval;

 

=={{header|Ruby}}==

a * b

 

=={{header|Sather}}==

-- we cannot have "functions" (methods) outside classes

mult(a, b:FLT):FLT is return a*b; end;

#OUT + mult(5.2, 3.4) + "\n";

end;

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

Alternately,

 

=={{header|Seed7}}==

 

 

=={{header|Slate}}==

or using a macro:

The block may also be installed as a method like so:

or more explicitly (without sugar):

 

=={{header|Smalltalk}}==

 

=={{header|SNOBOL4}}==

multiply multiply = a * b :(return)

mul_end

output = multiply(10.1,12.2)

output = multiply(10,12)

123.22

120

 

=={{header|SNUSP}}==

For expediency, the function is adding three values, instead of multiplying two values. Another function, atoi (+48) is called before printing the result.

| | \=itoa=@@@+@+++++#

\=======!\==!/===?\<#

 

=={{header|SPARK}}==

The function definition (multiplies two standard Integer):

function Multiply (A, B : Integer) return Integer;

--# pre A * B in Integer; -- See note below

--# return A * B; -- Implies commutativity on Multiply arguments

 

The Multiply's implementation:

function Multiply (A, B : Integer) return Integer is

begin

return A * B;

end Multiply;

 

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

Equivalently,

Curried form:

 

 

Strictly as described in the task:

return [expr {$arg1 * $arg2}]

{{works with|Tcl|8.5}}

You can also create functions that work directly inside expressions. This is done by creating the command with the correct name (that is, in the ''tcl::mathfunc'' namespace):

return [expr {$arg1 * $arg2}]

}

if {multiply(6, 9) == 42} {

puts "Welcome, Citizens of Golgafrincham from the B-Ark!"

 

 

 

 

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

{{works with|Bash}}

return an exit code

return $(($1 * $2))

}

multiply 5 6

echo the result

echo -n $(($1 * $2))

}

 

 

=={{header|Ursala}}==

Functions are declared with an equals sign like constants of any other type.

This is the definition in point free form,

this is the definition using lambda abstraction

and this is the definition using pattern matching.

 

=={{header|V}}==

Using it

V also allows internal bindings.

[a b] let

 

 

 

 

 

 

 

=={{header|X86 Assembly}}==

{{works with|NASM}}

global _start

_multiply_regs:

_multiply_stack:

_start:

 

{{works with|MASM}}

Then to call it.

;or..

push 16

push 6

Return values are usually put into the register EAX. This, of course is not a must it's simply that it's somewhat of a unofficial standard. For example, C/C++ preprocessors/compilers will translate "return value" into "mov eax, value" followed by the return to caller instruction "ret".