Function definition: Difference between revisions
→{{header|langur}}: modified to suit task description
m (→{{header|Wren}}: Changed to Wren S/H) |
Langurmonkey (talk | contribs) (→{{header|langur}}: modified to suit task description) |
||
(14 intermediate revisions by 7 users not shown) | |||
Line 419:
end</syntaxhighlight>
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
Handler names followed by zero or more parameters within parentheses are called "positional" -- the number and order of the parameters in the caller must match those in the handler definition.
<syntaxhighlight lang="applescript">on multiply(a, b)
Line 427 ⟶ 429:
multiply(2, 3)</syntaxhighlight>
AppleScript also offers handlers with "
These prepositions can be used: <code>about, above, against, apart from, around, aside from, at, below, beneath, beside, between, by, for, from, instead of, into, on, onto, out of, over, since, thru, through, and under</code>. Also, <code>of</code> is available, but if used it must be the first parameter.
Example:
<syntaxhighlight lang="applescript">on multiplication of a by b
Line 656 ⟶ 662:
=={{header|BASIC}}==
==={{header|ANSI BASIC}}===
In ANSI BASIC, functions can be defined as either formulas or multi-line external or internal subroutines. External functions are independent program units that can be called from within the program. Internal functions are considered part of the program unit they are contained in and can only be called from within that unit. External functions do not share any information with other program units and exchange information through parameters and returned values. Internal functions share everything with their surrounding program unit except for their parameters. Internal functions do not have local variables.
{{works with|Decimal BASIC}}
<syntaxhighlight lang="basic">
100 DEF Multiply(A,
120 DECLARE EXTERNAL FUNCTION MultiplyE
130 PRINT Multiply(3, 1.23456)
140 PRINT MultiplyI(3, 1.23456)
150 PRINT MultiplyE(3, 1.23456)
160 FUNCTION MultiplyI(X, Y)
170 LET MultiplyI = X * Y
180 END FUNCTION
190 END
200 EXTERNAL FUNCTION MultiplyE(A, B)
210 LET MultiplyE = A * B
220 END FUNCTION
</syntaxhighlight>
{{out}}
<pre>
3.70368
3.70368
3.70368
</pre>
==={{header|Applesoft BASIC}}===
Line 764 ⟶ 788:
<syntaxhighlight lang="freebasic">#Define multiply(d1, d2) (d1) * (d2)</syntaxhighlight>
==={{header|FutureBasic}}===
<syntaxhighlight lang="futurebasic">window 1
local fn multiply( a as long, b as long ) as long
end fn = a * b
print fn multiply( 3, 9 )
HandleEvents</syntaxhighlight>
Output:
<pre>
27
</pre>
==={{header|Gambas}}===
Line 952 ⟶ 990:
{{out}}
<pre> 3.703680038452148</pre>
==={{header|QuickBASIC}}===
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">DECLARE FUNCTION multiply% (a AS INTEGER, b AS INTEGER)
FUNCTION multiply% (a AS INTEGER, b AS INTEGER)
multiply = a * b
END FUNCTION</syntaxhighlight>
==={{header|REALbasic}}===
Line 1,041 ⟶ 1,087:
return a * b
end sub</syntaxhighlight>
==={{header|Xojo}}===
<syntaxhighlight lang="vbnet">Function Multiply(ByVal a As Integer, ByVal b As Integer) As Integer
Return a * b
End Function</syntaxhighlight>
Call the function
<syntaxhighlight lang="vbnet">Dim I As Integer = Multiply(7, 6)</syntaxhighlight>
==={{header|ZX Spectrum Basic}}===
Line 1,096 ⟶ 1,149:
print multiply(3, 2)</syntaxhighlight>
=={{header|Binary Lambda Calculus}}==
In lambda calculus, multiplication on Church numerals is <code>mul = \m \n \f. m (n f)</code> which in BLC is
<pre>00 00 00 01 1110 01 110 10</pre>
If mul is used several times within an expression E, then they can share the same definition by using <code>(\mul. E)(\m\n\f. m (n f))</code>. For example, the cube function is <code>\n. (\mul. mul n (mul n n)) (\m\n\f. m (n f))</code> which in BLC is
<pre>00 01 00 01 01 10 110 01 01 10 110 110 0000000111100111010</pre>
=={{header|BQN}}==
Line 1,156 ⟶ 1,219:
return a*b;
}</syntaxhighlight>
=={{header|Chapel}}==
<syntaxhighlight lang="text">
proc multiply(a, b)
{
return a * b;
}
</syntaxhighlight>
Can require that the two arguments be of the same type.
<syntaxhighlight lang="text">
proc multiply(a : ?t ... 2)
{
return a(0) * a(1)
}
</syntaxhighlight>
Will work on any type where the * operator is defined.
=={{header|ChucK}}==
Line 1,811 ⟶ 1,893:
let multiply (x: i32, y: i32) : i32 = x * y
</syntaxhighlight>
=={{header|GAP}}==
Line 2,134 ⟶ 2,202:
=={{header|langur}}==
<syntaxhighlight>
val multiply = fn{*}
</syntaxhighlight>
<syntaxhighlight>
val multiply = fn a, b: a * b
</syntaxhighlight>
<syntaxhighlight>
val multiply = fn(a, b) { a * b }
</syntaxhighlight>
=={{header|Lasso}}==
Line 2,776 ⟶ 2,824:
After a <tt>function</tt> has been activated, there must have be ''exactly one'' assignment to the (implicitly declared) variable bearing the same name as of the function.
Many processors do not comply with this specification, though, and allow ''overwriting'' the return value ''multiple'' times.
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
function multiply(a,b: real): real := a + b;
</syntaxhighlight>
=={{header|Perl}}==
Line 3,593 ⟶ 3,646:
<syntaxhighlight lang="scheme">(define multiply
(lambda (x y) (* x y)))</syntaxhighlight>
=={{header|XPL0}}==
|