Anonymous user
Return multiple values: Difference between revisions
add BLC solution
imported>Tromp (add BLC solution) |
|||
(31 intermediate revisions by 20 users not shown) | |||
Line 10:
{{trans|Python}}
<
R (x + y, x - y)
V (summ, difference) = addsub(33, 12)
print(‘33 + 12 = ’summ)
print(‘33 - 12 = ’difference)</
{{out}}
Line 26:
A function can return multiple values by storing them in two or more registers, or in user RAM.
Functions are typically called as a subroutine, e.g. <code>JSR UnpackNibbles</code>.
<
; Takes accumulator as input.
; Separates a two-digit hex number into its component "nibbles." Left nibble in X, right nibble in Y.
Line 40:
lsr
tax ;store in X
rts</
=={{header|68000 Assembly}}==
Line 49:
D2+D3 is returned in D0, D2-D3 is returned in D1.
<
MOVE.L D2,D0
MOVE.L D3,D1
Line 55:
SUB.L D2,D3
MOVE.L D3,D1
RTS</
=={{header|8086 Assembly}}==
Line 63:
This function takes two 16-bit numbers in CX and DX, and outputs their sum to AX and their difference to BX.
<
mov bx,dx
add ax,bx
sub cx,dx
mov bx,cx
ret</
=={{header|ACL2}}==
<
(defun multiple-values (a b)
(mv a b))
Line 78:
(mv-let (x y)
(multiple-values 1 2)
(+ x y))</
<br><br>
Line 84:
The user must type in the monitor the following command after compilation and before running the program!<pre>SET EndProg=*</pre>
{{libheader|Action! Tool Kit}}
<
INCLUDE "D2:ALLOCATE.ACT" ;from the Action! Tool Kit. You must type 'SET EndProg=*' from the monitor after compiling, but before running this program!
Line 164:
Free(p,RECORD_SIZE)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Return_multiple_values.png Screenshot from Atari 8-bit computer]
Line 184:
a procedure with 'out' parameters.
By default, all parameters are 'in', but can also be 'out', 'in out' and 'access'. Writing to an 'out' parameter simply changes the value of the variable passed to the procedure.
<syntaxhighlight lang="ada">
with Ada.Text_IO; use Ada.Text_IO;
procedure MultiReturn is
Line 199:
Put_Line ("Diff:" & Integer'Image (thediff));
end MultiReturn;
</syntaxhighlight>
{{out}}
<pre>
Line 210:
<br>
Tested with Agena 2.9.5 Win32
<
mv := proc() is
return 1, 2, "three"
Line 218:
local a, b, c := mv();
print( c, b, a )
epocs</
=={{header|ALGOL 68}}==
Line 224:
Procedures in Algol 68 can only return one value, so to return multiple values,
a structure (or array if all the values have the same mode) can be used.
<
MODE PAIR = STRUCT( STRING name, INT value );
Line 242:
# access the components separately #
print( ( name OF get pair( 1 ), value OF get pair( 2 ), newline ) )
)</
{{out}}
<pre>
Line 251:
=={{header|ALGOL W}}==
Algol W procedures can't return arrays but records can be used to return multiple values.
<
% example using a record type to return multiple values from a procedure %
record Element ( string(2) symbol; integer atomicNumber );
Line 278:
end
end.</
=={{header|
Hopper posee una pila de trabajo de alcance global; luego, los datos pueden ser puestos ahí y accedidos desde cualquier parte del programa.
<syntaxhighlight lang="c">
#include <basico.h>
#proto foo(_X_,_Y_)
algoritmo
_foo(10,1), decimales '13', imprimir
números(v,w,x,y,z, suma)
_foo(0.25,0) ---retener(5)--- sumar todo,
mover a 'v,w,x,y,z,suma'
imprimir(NL,v,NL, w,NL, x,NL, y,NL, z,NL,NL,suma,NL)
terminar
subrutinas
foo(c,sw)
#(c*10), solo si( sw, NL)
#(c/100), solo si( sw, NL)
#(0.25^c), solo si( sw, convertir a notación; NL)
#(2-(sqrt(c))), solo si( sw, NL)
cuando ' #(!(sw)) '{
#( ((c^c)^c)^c )
}
retornar
</syntaxhighlight>
{{out}}
<pre>
100.0000000000000
0.1000000000000
9.536743e-07
-1.1622776601684
2.5000000000000
0.0025000000000
0.7071067811865
1.5000000000000
0.9785720620877
5.6881788432742
</pre>
=={{header|ARM Assembly}}==
Line 299 ⟶ 332:
This function takes two numbers in <code>R0</code> and <code>R1</code>, and returns their sum in <code>R0</code> and their difference in <code>R1</code>.
<syntaxhighlight lang="arm assembly">foo:
MOV R2,R0
MOV R3,R1
ADD R0,R2,R3
SUB R1,R2,R3
BX LR</
=={{header|Arturo}}==
<
@[x+y x-y]
Line 316 ⟶ 349:
print [a "+" b "=" result\0]
print [a "-" b "=" result\1]</
{{out}}
Line 325 ⟶ 358:
=={{header|ATS}}==
Every function returns one value. The conventional way to return multiple values is to return a tuple.
<syntaxhighlight lang="ats">//
#include
"share/atspre_staload.hats"
Line 344 ⟶ 377:
println! ("33 + 12 = ", sum);
println! ("33 - 12 = ", diff);
end (* end of [main0] *)</
=={{header|AutoHotkey}}==
{{works with|AutoHotkey_L}}
Functions may return one value. The conventional way to return multiple values is to bundle them into an Array.
<
return [x + y, x - y]
}</
=={{header|AutoIt}}==
Return an array.
<syntaxhighlight lang="autoit">
Func _AddSub($iX, $iY)
Local $aReturn[2]
Line 362 ⟶ 395:
Return $aReturn
EndFunc
</syntaxhighlight>
=={{header|BASIC}}==
==={{header|ANSI BASIC}}===
{{works with|Decimal BASIC}}
The most straightforward way of returning multiple values is to specify them as parameters.
<syntaxhighlight lang="basic">100 DECLARE EXTERNAL SUB sumdiff
110 !
120 CALL sumdiff(5, 3, sum, diff)
130 PRINT "Sum is "; sum
140 PRINT "Difference is "; diff
150 END
160 !
170 EXTERNAL SUB sumdiff(a, b, c, d)
180 LET c = a + b
190 LET d = a - b
200 END SUB</syntaxhighlight>
{{out}}
<pre>
Sum is 8
Difference is 2
</pre>
==={{header|BaCon}}===
BaCon can return homogeneous dynamic arrays, or RECORD data holding heterogeneous types.
<
RECORD multi
LOCAL num
Line 386 ⟶ 439:
PRINT rec.num
PRINT rec.s$[0]
PRINT rec.s$[1]</
{{out}}
Line 396 ⟶ 449:
==={{header|BBC BASIC}}===
The most straightforward way of returning multiple values is to specify them as RETURNed parameters.
<
PRINT "Sum is " ; sum
PRINT "Difference is " ; diff
Line 404 ⟶ 457:
c = a + b
d = a - b
ENDPROC</
==={{header|IS-BASIC}}===
<
110 CALL SUMDIFF(5,3,SUM,DIFF)
120 PRINT "Sum is";SUM:PRINT "Difference is";DIFF
Line 413 ⟶ 466:
140 DEF SUMDIFF(A,B,REF C,REF D)
150 LET C=A+B:LET D=A-B
160 END DEF</
==={{header|uBasic/4tH}}===
{{Trans|Forth}}
uBasic/4tH shares many features with Forth - like a stack. Parameters of functions and procedures are passed through this stack, so there is no difference between pushing the values on the stack ''or'' passing them as function parameters. Return values are passed by the stack as well, so if we push additional values ''before'' calling '''RETURN''' we can retrieve them using '''POP()'''.
<syntaxhighlight lang="qbasic">a = FUNC (_MulDiv (33, 11))
b = Pop()
Print "a * b = ";a, "a / b = ";b
Push 33, 11 : Proc _MulDiv
a = Pop() : b = Pop()
Print "a * b = ";a, "a / b = ";b
End
_MulDiv
Param (2)
Push a@ / b@
Return (a@ * b@)</syntaxhighlight>
{{Out}}
<pre>a * b = 363 a / b = 3
a * b = 363 a / b = 3
0 OK, 0:226 </pre>
=={{header|Binary Lambda Calculus}}==
In the lambda calculus, one can return a tuple, which when applied to a function f, applies f to all the tuple elements. For example, <A,B,C> is <code>\f.f A B C</code>. Alternatively, one can use continuation-passing-style (cps), in which the function f is not applied the tuple return value, but instead is passed as an extra initial argument, and then the function can return f applied to the multiple values.
=={{header|BQN}}==
BQN is an array language, and hence arrays are the method of returning multiple values from a function. These values can then be separated with pattern matching.
<syntaxhighlight lang="bqn"> Func←{⟨𝕩+1, 𝕩÷2, 𝕩×3⟩}
(function block)
a‿b‿c←Func 3
⟨ 4 1.5 9 ⟩
a
4
b
1.5
c
9</syntaxhighlight>
=={{header|Bracmat}}==
{{trans|Haskell}}
Every function returns one value. The conventional way to return multiple values is to return a tuple.
<
You can use pattern matching to extract the components:
<
& out$("33 + 12 = " !sum)
& out$("33 - 12 = " !difference)
);</
{{out}}
<pre>33 + 12 = 45
Line 430 ⟶ 523:
=={{header|C}}==
C has structures which can hold multiple data elements of varying types.
<
typedef struct{
Line 454 ⟶ 547:
return 0;
}</
{{out}}
<pre>
Line 461 ⟶ 554:
C99 and above also allow structure literals to refer to the name, rather than position, of the element to be initialized:
<
typedef struct {
Line 478 ⟶ 571:
printf("The name's %s. %s %s.\n", me.last, me.first, me.last);
return 0;
}</
{{out}}
<pre>The name's Bond. James Bond.
Line 484 ⟶ 577:
=={{header|C sharp|C#}}==
The preferred way to return multiple values in C# is to use "out"
<
using System.Collections.Generic;
using System.Linq;
Line 506 ⟶ 599:
min = sortedNums.First();
}
}</
{{out}}
<pre>Min: -3
Line 513 ⟶ 606:
=={{header|C++}}==
Since C++11, the C++-standard-library includes tuples, as well as an easy way to destructure them.
<
#include <array>
#include <cstdint>
Line 531 ⟶ 624:
std::tie(min, max) = minmax(numbers.data(), numbers.size());
std::cout << "The smallest number is " << min << ", the biggest " << max << "!\n" ;
}</
{{out}}
<PRE>The smallest number is -10, the biggest 987!</PRE>
Line 538 ⟶ 631:
Every function returns one value.
The conventional way to return multiple values is to bundle them into an array.
<
Return { x+y, x-y }</
=={{header|Clojure}}==
Multiple values can be returned by packaging them in a vector.
At receiving side, these arguments can be obtained individually by using [http://blog.jayfields.com/2010/07/clojure-destructuring.html destructuring].
<
; The following prints 3 2.
(let [[q r] (quot-rem 11 3)]
(println q)
(println r))</
In complex cases, it would make more sense to return a map, which can be destructed in a similar manner.
<
{:q (quot m n)
:r (rem m n)})
Line 558 ⟶ 651:
(let [{:keys [q r]} (quot-rem 11 3)]
(println q)
(println r))</
=={{header|CLU}}==
<
% was actually invented with CLU.
Line 590 ⟶ 683:
stream$putl(po, "33 + 12 = " || int$unparse(sum))
stream$putl(po, "33 - 12 = " || int$unparse(diff))
end start_up</
{{out}}
<pre>33 + 12 = 45
33 - 12 = 21</pre>
=={{header|CMake}}==
<
function(firstlast string first last)
# f = first character.
Line 611 ⟶ 704:
firstlast("Rosetta Code" begin end)
message(STATUS "begins with ${begin}, ends with ${end}")</
=={{header|COBOL}}==
Line 626 ⟶ 719:
{{works with|GnuCOBOL}}
<syntaxhighlight lang="cobol">
identification division.
program-id. multiple-values.
Line 700 ⟶ 793:
goback.
end function multiples.
</syntaxhighlight>
{{out}}
Line 714 ⟶ 807:
Returning a single value is accomplished by evaluating an expression (which itself yields a single value) at the end of a body of forms.
<
3)</
The next possibility is that of returning no values at all. For this, the <code>values</code> function is used, with no arguments:
<
(values))</
To combine the values of multiple expressions into a multi-value return, <code>values</code> is used with arguments. The following is from an interactive [[CLISP]] session. CLISP's listener shows multiple values separated by a semicolon:
<
ADD-SUB
[2]> (add-sub 4 2) ; 6 (primary) and 2
Line 731 ⟶ 824:
10
[5]> (multiple-value-call #'+ (add-sub 4 2) (add-sub 3 1)) ; 6+2+4+2
14</
What happens if something tries to use the value of a form which returned <code>(values)</code>? In this case the behavior defaults to taking the value <code>nil</code>:
<
What if the <code>values</code> function is applied to some expressions which also yield multiple values, or which do not yield any values? The answer is that only the primary value is taken from each expression, or the value <code>nil</code> for any expression which did not yield a value:
<
yields three values:
<pre>-> 1; NIL; A</pre>
This also means that <code>values</code> can be used to reduce a multiple value to a single value:
<
;; nil if expr returns no values
(values expr)</
Multiple values are extracted in several ways.
1. Binding to variables:
<
;; in this scope dividend is 5; remainder is 1
)</
2. Conversion to a list:
<
3. Reification of multiple values as arguments to another function:
<
(multiple-value-call #'+ (truncate 16 3))</
4. Assignment to variables:
<
(multiple-value-setq (dividend remainder) (truncate 16 1))</
<code>(values ...)</code> syntax is treated as a multiple value place by <code>setf</code> and other operators, allowing the above to be expressed this way:
<
=={{header|Cowgol}}==
<
# In Cowgol, subroutines can simply define multiple output parameters.
Line 789 ⟶ 882:
print("Min: "); print_i8(least); print_nl();
print("Max: "); print_i8(most); print_nl();</
{{out}}
Line 797 ⟶ 890:
=={{header|D}}==
<
Line 824 ⟶ 917:
writefln("33 + 12 = %d\n33 - 12 = %d", a, b);
}</
{{out}}
<pre>33 + 12 = 45
Line 831 ⟶ 924:
=={{header|Dc}}==
Define a divmod macro <code>~</code> which takes <code>a b</code> on the stack and returns <code>a/b a%b</code>.
<
1337 42 l~ x f</
{{out}}
<pre>35
Line 839 ⟶ 932:
=={{header|Delphi}}/{{header|Pascal}}==
Delphi functions return a single value, but var parameters of a function or procedure can be modified and act as return values.
<
{$APPTYPE CONSOLE}
Line 855 ⟶ 948:
Writeln(x);
Writeln(y);
end.</
=={{header|Dyalect}}==
Line 861 ⟶ 954:
A typical way to return multiple values in Dyalect is to use tuples:
<
(x / y, x % y)
}</
=={{header|Déjà Vu}}==
<
10 20
!print !print function-returning-multiple-values
</syntaxhighlight>
{{out}}
<pre>10
20</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
proc addSubtract a b . sum diff .
sum = a + b
diff = a - b
.
addSubtract 7 5 sum diff
print "Sum: " & sum
print "Difference: " & diff
</syntaxhighlight>
{{out}}
<pre>
Sum: 12
Difference: 2
</pre>
=={{header|EchoLisp}}==
One can return the result of the '''values''' function, or a list.
<
(define (plus-minus x y)
(values (+ x y) (- x y)))
Line 888 ⟶ 997:
(plus-minus 3 4)
→ (7 -1)
</syntaxhighlight>
=={{header|ECL}}==
<syntaxhighlight lang="text">MyFunc(INTEGER i1,INTEGER i2) := FUNCTION
RetMod := MODULE
EXPORT INTEGER Add := i1 + i2;
Line 902 ⟶ 1,011:
MyFunc(3,4).Add;
MyFunc(3,4).Prod;
</syntaxhighlight>
=={{header|Eiffel}}==
Every function returns one value. Multiple values can be returned in a tuple.
<
do
Result := [1, 'j', "r"]
end</
Greater control over the type of return values can also be enforced by explicitly declaring the type of the generic parameters.
<
do
--Result := [ ] -- compile error
Line 917 ⟶ 1,026:
Result := [1, 'j', "r"] -- okay
Result := [1, 'j', "r", 1.23] -- also okay
end</
=={{header|Elena}}==
ELENA
<
import extensions;
Line 942 ⟶ 1,051:
console.printLine("Min: ",min," Max: ",max)
}</
=== Using Tuples syntax ===
<syntaxhighlight lang="elena">import system'routines;
import extensions;
extension op
{
::(int, int) MinMax()
{
var ordered := self.ascendant();
^ (ordered.FirstMember, ordered.LastMember);
}
}
public program()
{
var values := new int[]{4, 51, 1, -3, 3, 6, 8, 26, 2, 4};
(int min, int max) := values.MinMax();
console.printLine("Min: ",min," Max: ",max)
}</syntaxhighlight>
{{out}}
<pre>
Line 950 ⟶ 1,081:
=={{header|Elixir}}==
Elixir returns in the tuple form when returning more than one value.
<
def addsub(a, b) do
{a+b, a-b}
Line 957 ⟶ 1,088:
{add, sub} = RC.addsub(7, 4)
IO.puts "Add: #{add},\tSub: #{sub}"</
{{out}}
Line 965 ⟶ 1,096:
=={{header|Erlang}}==
<
-module(return_multi).
Line 975 ⟶ 1,106:
multiply(A, B) ->
{A * B, A + B, A - B}.
</syntaxhighlight>
{{out}}
<pre>12 7 -1
Line 982 ⟶ 1,113:
=={{header|ERRE}}==
FUNCTIONs in ERRE language return always a single value, but PROCEDUREs can return multiple values defining a parameter output list in procedure declaration using '->' separator.
<syntaxhighlight lang="erre">
PROGRAM RETURN_VALUES
Line 995 ⟶ 1,126:
PRINT("Difference is";DIFF)
END PROGRAM
</syntaxhighlight>
=={{header|Euler}}==
Euler procedures can return a list (Euler's only data structure), this is used here to return three values from the getMV procedure.
<br>
Procedures are defined by enclosing their text between ` and '. They can then be assigned to a variable for later use.
<br>
Lists are constructed by placing the values between ( and ). Once assigned to a variable, the list can be subscripted to access the individual elements (which can themselves be lists).
'''begin'''
'''new''' mv; '''new''' getMV;
getMV <- ` '''formal''' v; ( v, v * v, v * v * v ) ';
mv <- getMV( 3 );
'''out''' mv[ 1 ];
'''out''' mv[ 2 ];
'''out''' mv[ 3 ]
'''end''' $
=={{header|Euphoria}}==
Any Euphoria object can be returned. A sequence of objects can be returned, made from multiple data types as in this example.
<
integer aWholeNumber = 1
Line 1,012 ⟶ 1,161:
result = addmultret(aWholeNumber, aFloat, aSequence) --call function, assign what it gets into result - {9.999999, 23.999988}
? result
any_key()</
{{out}}
Line 1,021 ⟶ 1,170:
A function always returns exactly one value.
To return multiple results, they are typically packed into a tuple:
<
let sum, diff = addSub 33 12
printfn "33 + 12 = %d" sum
printfn "33 - 12 = %d" diff</
Output parameters from .NET APIs are automatically converted to tuples by the compiler.
Line 1,033 ⟶ 1,182:
With stack-oriented languages like Factor, a function returns multiple values by pushing them on the data stack.
For example, this word ''*/'' pushes both x*y and x/y.
<
IN: script
Line 1,042 ⟶ 1,191:
[ "15 * 3 = " write . ]
[ "15 / 3 = " write . ] bi*</
Its stack effect declares that ''*/'' always returns 2 values. To return a variable number of values, a word must bundle those values into a [[sequence]] (perhaps an array or vector). For example, ''factors'' (defined in ''math.primes.factors'' and demonstrated at [[Prime decomposition#Factor]]) returns a sequence of prime factors.
=={{header|FALSE}}==
<
6 2f;! .
=={{header|Forth}}==
It is natural to return multiple values on the parameter stack. Many built-in operators and functions do so as well ('''/mod''', '''open-file''', etc.).
<
2dup / >r * r> ;</
=={{header|Fortran}}==
{{trans|Haskell}}
<
implicit none
type res
Line 1,076 ⟶ 1,225:
print *, addsub(33, 22)
end program
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
' One way to return multiple values is to use ByRef parameters for the additional one(s)
Line 1,131 ⟶ 1,280:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 1,144 ⟶ 1,293:
=={{header|Frink}}==
The most common way of returning multiple values from a function is to return them as an array, which can be disassembled and set into individual variables on return.
<
divMod[a, b] := [a div b, a mod b]
[num, remainder] = divMod[10, 3]
</syntaxhighlight>
=={{header|FunL}}==
{{trans|Scala}}
<
val (sum, difference) = addsub( 33, 12 )
println( sum, difference, addsub(33, 12) )</
{{out}}
Line 1,168 ⟶ 1,317:
Here is an example of returning multiple values using pointers:
<
local fn ReturnMultipleValues( strIn as Str255, strOut as ^Str255, letterCount as ^long )
// Test if incoming string is empty, and exit function if it is
if strIn[0] == 0 then exit fn
// Prepend this string to incoming string and return it
s = "Here is your original string: "
strOut.nil$ = s + strIn
// Get length of combined string and return it
// Note: In FutureBasic string[0] is interchangeable with Len(string)
letterCount.nil& = strIn[0] + s[0]
end fn
fn ReturnMultipleValues( "Hello, World!", @outStr, @outCount )
print outStr; ". The combined strings have ";
HandleEvents
</syntaxhighlight>
Output:
Line 1,199 ⟶ 1,348:
Another way to pass multiple values from a function is with records (AKA structures):
<syntaxhighlight lang="text">
// Elements in global array
_maxDim = 3
begin record Addresses
end record
begin globals
end globals
local fn FillRecord( array(_maxDim) as Addresses )
array.name(0) = "John Doe"
array.name(1) = "Mary Jones"
array.name(2) = "Bill Smith"
array.phone(0) = "555-359-4411"
array.phone(1) = "555-111-2211"
array.phone(2) = "555-769-8071"
array.zip(0) = 12543
array.zip(1) = 67891
array.zip(2) = 54321
end fn
Line 1,232 ⟶ 1,379:
fn FillRecord( gAddressData(0) )
for i = 0 to 2
next
HandleEvents
</syntaxhighlight>
Output:
Line 1,249 ⟶ 1,397:
You can also use global arrays to return multiple values from a function as in this example:
<syntaxhighlight lang="text">
// Elements in global array
_maxDim = 3
begin globals
end globals
Line 1,262 ⟶ 1,408:
array( 0, 0 ) = "John Doe"
array( 1, 0 ) = "Mary Jones"
array( 2, 0 ) = "Bill Smith"
array( 0, 1 ) = "555-359-4411"
Line 1,276 ⟶ 1,422:
fn FillRecord( gAddressArray( 0, 0 ) )
for i = 0 to 2
next
HandleEvents
</syntaxhighlight>
Output:
Line 1,294 ⟶ 1,442:
Here is another example using FB's containers -- bit buckets that can hold up to 2GB of data contingent on system memory.
<syntaxhighlight lang="text">
begin globals
// An FB container can hold up to 2GB of data, contingent on system memory
end globals
Line 1,341 ⟶ 1,487:
// Check the new results
print gC1 : print gC2
HandleEvents
</syntaxhighlight>
Output:
Line 1,366 ⟶ 1,514:
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Return_multiple_values}}
'''Solution'''
Every function returns one value. The conventional way to return multiple values is to return a list.
In the following example, the function returns the sum and product of two given numbers.
[[File:Fōrmulæ - Return multiple values 01.png]]
[[File:Fōrmulæ - Return multiple values 02.png]]
[[File:Fōrmulæ - Return multiple values 03.png]]
=={{header|Go}}==
Functions can return multiple values in Go:
<
return x + y, x - y
}</
Or equivalently using named return style:
<
sum = x + y
difference = x - y
return
}</
When a function returns multiple values, you must assign to a comma-separated list of targets:
<
fmt.Printf("33 + 12 = %d\n", sum)
fmt.Printf("33 - 12 = %d\n", difference)</
::<
import (
Line 1,450 ⟶ 1,606:
puss, poo := myCat.Puss()
fmt.Println(puss, poo) // prt Kitty Cat
}</
=={{header|Groovy}}==
In Groovy functions return one value. One way to return multiple ones is to use anonymous maps as a sort of tuple.
<
[
sum: x+y,
difference: x-y
]
}</
Result:
<
["sum":22, "difference":-2]</
And although Groovy functions only return one value, Groovy ''assignments'' of Iterable objects (lists, arrays, sets, etc.) can be distributed across multiple ''variables'', like this:
<
[ x+y , x-y ]
}
Line 1,473 ⟶ 1,629:
def (sum, diff) = addSub2(50, 5)
assert sum == 55
assert diff == 45</
If there are fewer elements than variables, the leftover variables are assigned null. If there are more elements than variables, the last variable is assigned the collected remainder of the elements.
Line 1,479 ⟶ 1,635:
=={{header|Harbour}}==
Every function returns one value. The conventional way to return multiple values is to bundle them into an array.
<
RETURN { x + y, x - y }</
However, we can 'return' multiple individual values, that are produced/processed/altered inside a function, indirectly, passing parameters `by reference`.
For example:
<syntaxhighlight lang="visualfoxpro">
PROCEDURE Main()
LOCAL Street, City, Country
IF GetAddress( @Street, @City, @Country )
? hb_StrFormat( "Adrress: %s, %s, %s", Street, City, Country )
// output: Route 42, Android-Free Town, FOSSLAND
ELSE
? "Cannot obtain address!"
ENDIF
FUNCTION GetAddress( cS, cC, cCn)
cS := "Route 42"
cC := "Android-Free Town"
cCn:= "FOSSLAND"
RETURN .T.
</syntaxhighlight>
=={{header|Haskell}}==
Every function returns one value. The conventional way to return multiple values is to return a tuple.
<
You can use pattern matching to extract the components:
<
let (sum, difference) = addsub 33 12
putStrLn ("33 + 12 = " ++ show sum)
putStrLn ("33 - 12 = " ++ show difference)</
=={{header|Icon}} and {{header|Unicon}}==
Line 1,495 ⟶ 1,671:
The following examples return 1, 2, 3 in different ways:
<
return [1,2,3]
end
Line 1,520 ⟶ 1,696:
procedure retRecord() # return as a record, least general method
return retdata(1,2,3)
end</
=={{header|J}}==
To return multiple values in J, you return an array which contains multiple values. Since the only data type in J is array (this is an oversimplification, from some perspectives - but those issues are out of scope for this task), this is sort of like asking how to return only one value in another language.
<
4 6</
=={{header|Java}}==
Java does not have tuples, so the most idiomatic approach would be to create a nested or inner-class specific to your values.
<syntaxhighlight lang="java">
Point getPoint() {
return new Point(1, 2);
}
static class Point {
int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
</syntaxhighlight>
It is not recommended to return an ''Object'' array from a method.<br />
This will require the receiving procedure a casting operation, possibly preceded by an ''instanceof'' conditional check.<br /><br />
If you're using objects that are not known until runtime, use Java Generics.
<syntaxhighlight lang="java">
Values<String, OutputStream> getValues() {
return new Values<>("Rosetta Code", System.out);
}
static class Values<X, Y> {
X x;
Y y;
public Values(X x, Y y) {
this.x = x;
this.y = y;
}
}
</syntaxhighlight>
<br />
Or, an alternate demonstration
{{trans|NetRexx}}
<
import java.util.ArrayList;
import java.util.Map;
Line 1,628 ⟶ 1,839:
}
}
}</
'''Otherwise'''
<
private final Object[] objects;
public Values(Object ... objects) {
Line 1,660 ⟶ 1,871:
System.out.println();
}
}</
{{out}}
<pre>
Line 1,670 ⟶ 1,881:
=={{header|JavaScript}}==
Javascript does not support multi-value bind until ECMAScript 6 is released (still a draft as of May 2015). The multi-value return is actually a destructured binding. Support may not be present yet in most implementations.
<
var arrBind = function () {
return [1, 2, 3]; //return array of three items to assign
Line 1,693 ⟶ 1,904:
var {baz: foo, buz: bar} = objBind();//assigns baz => "abc", buz => "123"
//keep rest of values together as object
var {foo, ...rest} = objBind();//assigns foo => "abc, rest => {bar: "123", baz: "zzz"}</
=={{header|jq}}==
jq supports streams of JSON values, so there are two main ways in which a function can return multiple values: as a stream, or as an array. Using the same example given for the Julia entry: <
def addsub(x; y): (x + y), (x - y);
# To produce an array:
def add_subtract(x; y): [ x+y, x-y ];
</syntaxhighlight>
The builtin filter .[] streams its input if the input is an array, e.g. the expression <code>[1,2] | .[]</code> produces the stream:<
1
2</
=={{header|Julia}}==
<
return x + y, x - y
end</
<pre>julia> addsub(10,4)
(14,6)</pre>
Line 1,715 ⟶ 1,926:
=={{header|Kotlin}}==
Although Kotlin doesn't support tuples as such, it does have generic Pair and Triple types which can be used to return 2 or 3 values from a function. To return more values, a data class can be used. All of these types can be automatically destructured to separate named variables.
<
/* implicitly returns a Pair<Int, Int>*/
Line 1,725 ⟶ 1,936:
println("The smallest number is $min")
println("The largest number is $max")
}</
{{out}}
Line 1,735 ⟶ 1,946:
=={{header|Lambdatalk}}==
Lambdatalk can retun several values glued into conses or arrays.
<
{def foo
{lambda {:n}
Line 1,751 ⟶ 1,962:
{bar 10}
-> [9,10,11]
</syntaxhighlight>
=={{header|Lasso}}==
<
return (:'hello word',date)
}
Line 1,762 ⟶ 1,973:
'x: '+#x
'\ry: '+#y</
{{out}}
<pre>x: hello word
Line 1,770 ⟶ 1,981:
=={{header|Liberty BASIC}}==
Using a space-delimited string to hold the array. LB functions return only one numeric or string value, so the function returns a string from which can be separated the two desired values.
<
a$ =minMax$( data$)
Line 1,790 ⟶ 2,001:
loop until 0
minMax$ =str$( min) +" " +str$( max)
end function</
<pre>
Minimum was -5 & maximum was 22
Line 1,798 ⟶ 2,009:
No support for returning multiple values, but (similar to Scala), a Tuple can be returned.
<
{
return <[a, b]>
}</
The current version (0.17) has no support for destructuring Tuple assigns.
=={{header|Lua}}==
<
return a+b, a-b
end
s, d = addsub( 7, 5 )
print( s, d )</
=={{header|M2000 Interpreter}}==
Functions can be made in 5 ways: Normal, Lambda, Simple, Group which return value, Pointer to Group which return value. For every way we can return multiple values as tuple (in a mArray type of array). The (a,b)=funcA() is a way to define/assign values from tuple. So (a,b)=(1, 2) is the simple form. A return value from a function done using = as statement. This return isn't the last statement (isn't exit from function), so may we have multiple = as statements and the last one which we execute return the value. By default if we don't use the = statement based on function's suffix at name (at call) we get 0 or "". Functions can return any type of types. So the return type based on statement = (or the interpreter return 0 or "" based on name at call, where suffix $ means we return empty string, although later versions of language can return string/ make string variables without suffix $).
<syntaxhighlight lang="m2000 interpreter">
module Return_multiple_values{
Print "Using a function"
function twovalues(x) {
="ok", x**2, x**3
}
// this is a sugar syntax to apply a tuple (mArray type) to variables
// can be new variables or pre defined
// if they are predifined then overflow may happen
byte b
// object a=(,) // if a is an object we can't assign number
(s, a,b)=twovalues(3) // twovalues(30) raise overflow
Print a=9, b=27, s="ok"
c=twovalues(3)
// need to use val$() because val() on string type is like a Val("1233")
Print c#val$(0)="ok", c#val(1)=9, c#val(2)=27, type$(c)="mArray"
// we can pass by reference
callbyref(&twovalues())
sub callbyref(&a())
local a, b, s as string
(s, a,b)=a(3)
Print a=9, b=27, s="ok"
end sub
}
Return_multiple_values
// modules may change definitions like functions (but not subs and simple functions)
Module Return_multiple_values{
// lambdas are first citizens, can be called as functions or used as variables/values
Print "Using lambda function"
twovalues=lambda (x) ->{
="ok", x**2, x**3
}
byte b
(s, a,b)=twovalues(3) // twovalues(30) raise overflow
Print a=9, b=27, s="ok"
c=twovalues(3)
Print c#val$(0)="ok", c#val(1)=9, c#val(2)=27, type$(c)="mArray"
callbyref(&twovalues())
callbyValue(twovalues, 3)
sub callbyref(&a())
local a, b, s as string
(s, a,b)=a(3)
Print a=9, b=27, s="ok"
end sub
sub callbyValue(g, v)
local a, b, s as string
(s, a,b)=g(v)
Print a=9, b=27, s="ok"
end sub
}
Return_multiple_values
module Return_multiple_values{
Print "Using simple function (static)"
byte b
(s, a,b)=@twovalues(3) // twovalues(30) raise overflow
Print a=9, b=27, s="ok"
c=@twovalues(3)
Print c#val$(0)="ok", c#val(1)=9, c#val(2)=27, type$(c)="mArray"
function twovalues(x)
="ok", x**2, x**3
end function
}
Return_multiple_values
module Return_multiple_values {
// a group may used as function too
// we can use fields to alter state
// we can't pass the object as function by reference
// but we can pass an object function
// group is a static object to this module
// in every call of this module, this object initialised
// when the group statement executed
// and destroyed at the end of execution without a call to remove destructor
Print "Using a group as a function with a field"
group twovalues {
rep$="ok"
function forRef(x) {
=.rep$, x**2, x**3
}
value () { // ![] pass the stack of values to forRef function
if empty then =this: exit
=.forRef(![]) // or use =.rep$, x**2, x**3 and (x) at value
}
Set {
Error "no object change allowed"
}
}
byte b
// object a=(,) // if a is an object we can't assign number
(s, a,b)=twovalues(3)
Print a=9, b=27, s="ok"
twovalues.rep$="Yes"
c=twovalues(3)
// need to use val$() because val() on string type is like a Val("1233")
Print c#val$(0)="Yes", c#val(1)=9, c#val(2)=27, type$(c)="mArray"
callbyref(&twovalues.forRef())
callbyValue(twovalues, 3)
sub callbyref(&a())
local a, b, s as string
(s, a,b)=a(3)
Print a=9, b=27, s="Yes"
end sub
sub callbyValue(g, v)
local a, b, s as string
(s, a,b)=g(v)
Print a=9, b=27, s="Yes"
end sub
}
Return_multiple_values
module Return_multiple_values {
Print "Using a pointer to group as a function with a field (group created by a Class)"
class iTwovalues {
string rep
function forRef(x) {
=.rep, x**2, x**3
}
value () { // ![] pass the stack of values to forRef function
=.forRef(![])
}
Set {
Error "no object change allowed"
}
// optional here, only to return the destriyed event (after the module exit from execution)
remove {
print .rep+" destroyed"
}
class:
Module iTwovalues (.rep) {
}
}
byte b
// twovalues is a pointer to an object of general type Group
twovalues->iTwovalues("ok")
Print twovalues is type iTwovalues = true
(s, a,b)=Eval(twovalues, 3)
Print a=9, b=27, s="ok"
twovalues=>rep="Yes"
c=twovalues=>forRef(3) // better to call a function instead of use Eval()
Print c#val$(0)="Yes", c#val(1)=9, c#val(2)=27, type$(c)="mArray"
for twovalues {
// we have to use for object { } to use references to members of object
callbyref(&.forRef())
}
// if we hide the next statement we will see Yes destroyed after return from this module (before "done")
twovalues=pointer() // because twovalues is the last pointer to object, the object destroyed
// we see now: Yes destroyed
sub callbyref(&a())
local a, b, s as string
(s, a,b)=a(3)
Print a=9, b=27, s="Yes"
end sub
}
Return_multiple_values
Print "Done"
</syntaxhighlight>
=={{header|Maple}}==
<
> sumprod( x, y );
x + y, x y
> sumprod( 2, 3 );
5, 6</
The parentheses are needed here only because of the use of arrow ("->") notation to define the procedure. One could do, instead:
<
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
addsub[4,2]</
{{out}}
<pre>{6,2}</pre>
=={{header|MATLAB}} / {{header|Octave}}==
<
a = 1-d;
b = 2+d;
c = a+b;
end;
[x,y,z] = foo(5) </
{{out}}
<
x = -4
y = 7
z = 3 </
=={{header|Maxima}}==
<
[u, v]: f(5, 6);
[30, 11]</
=={{header|Mercury}}==
Line 1,856 ⟶ 2,229:
===addsub.m===
<
:- interface.
Line 1,883 ⟶ 2,256:
D = X - Y.
:- end_module addsub.</
===Use and output===
Line 1,895 ⟶ 2,268:
The above code can be modified so that the definition of <code>addsub/4</code> is now instead this function <code>addsub/2</code>:
<
addsub(X, Y) = { X + Y, X - Y }.</
Instead, now, of a predicate with two input and two output parameters of type <code>int</code>, addsub is a function that takes two <code>int</code> parameters and returns a tuple containing two <code>int</code> values. The call to <code>addsub/4</code> in the above code is now replaced by this:
<
All other code remains exactly the same as does the use and output of it.
Line 1,910 ⟶ 2,283:
An example of this follows:
<
:- interface.
Line 1,937 ⟶ 2,310:
addsub(X, Y) = twin(X + Y, X - Y).
:- end_module addsub.</
Here the type <code>my_result</code> has been provided with a <code>twin/2</code> constructor that accepts two <code>int</code> values. Use and output of the code is, again, exactly the same.
Line 1,946 ⟶ 2,319:
To return multiple values in min, simply leave them on the data stack.
{{works with|min|0.19.6}}
<
=={{header|MIPS Assembly}}==
The registers <code>$v0</code> and <code>$v1</code> are intended for return values. Technically you can use any register you want, but the calling conventions use <code>$v0</code> and <code>$v1</code>.
<syntaxhighlight lang="mips">sum:
add $v0,$a0,$a1
jr ra
nop ;branch delay slot</syntaxhighlight>
=={{header|Nemerle}}==
To return multiple values in Nemerle, package them into a tuple.
<
using System.Console;
using Nemerle.Assertions;
Line 1,972 ⟶ 2,352:
WriteLine($"Min of nums = $min; max of nums = $max");
}
}</
=={{header|NetRexx}}==
Line 1,978 ⟶ 2,358:
Another common idiom inherited from [[REXX]] is the ability to collect the return data into a simple NetRexx string. Caller can then use the <tt>PARSE</tt> instruction to deconstruct the return value and assign the parts to separate variables.
<
options replace format comments java crossref symbols nobinary
Line 2,080 ⟶ 2,460:
setRightVal(sv_)
return
</syntaxhighlight>
=={{header|Nim}}==
Every function returns one value. We can return a tuple instead:
<
(x + y, x - y)
var (a, b) = addsub(12, 15)</
Or manipulate the parameters directly:
<
a = x + y
b = x - y
var a, b: int
addsub(12, 15, a, b)</
=={{header|Objeck}}==
Easiest way to return multiple values is to use in/out objects. The language also supports returning collections.
<
function : Main(args : String[]) ~ Nil {
a := IntHolder->New(3); b := IntHolder->New(7);
Line 2,109 ⟶ 2,489:
a->Set(a->Get() + 2); b->Set(b->Get() + 13);
}
}</
=={{header|OCaml}}==
Every function returns one value. The conventional way to return multiple values is to return a tuple.
<
x + y, x - y</
(Note that parentheses are not necessary for a tuple literal in OCaml.)
You can use pattern matching to extract the components:
<
Printf.printf "33 + 12 = %d\n" sum;
Printf.printf "33 - 12 = %d\n" difference</
=={{header|Oforth}}==
Oforth uses a data stack. A function return is everything left on the stack when the function ends, so a function can return as many objects as needed :
<
: returnFourValues 12 13 14 15 ;
Line 2,134 ⟶ 2,514:
"\nShowing one object containing four values returned on the parameter stack:" println
returnOneObject .s clr</
Output:
Line 2,150 ⟶ 2,530:
=={{header|ooRexx}}==
Functions and methods in ooRexx can only have a single return value, but that return value can be some sort of collection or other object that contains multiple values. For example, an array:
<syntaxhighlight lang="oorexx">
r = addsub(3, 4)
say r[1] r[2]
Line 2,157 ⟶ 2,537:
use arg x, y
return .array~of(x + y, x - y)
</syntaxhighlight>
Output:
<pre>
Line 2,166 ⟶ 2,546:
Demonstrated with vectors, using OOP and a pseudo-assign trick:
<
'============
Line 2,211 ⟶ 2,591:
print aa.ShowValues() 'result 100,200,-300,400
</syntaxhighlight>
=={{header|PARI/GP}}==
The usual way to return multiple values is to put them in a vector:
<
[x^2, x^3]
};</
=={{header|Perl}}==
Functions may return lists of values:
<
my ($a, $b) = @_;
return $a + $b, $a * $b;
}</
=={{header|Phix}}==
{{libheader|Phix/basics}}
Every function returns one value. You can return any number of items as elements of a sequence, and unpack them on receipt or not.
<!--<
<span style="color: #008080;">function</span> <span style="color: #000000;">stuff</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">return</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"PI"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'='</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3.1415926535</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">{</span><span style="color: #004080;">string</span> <span style="color: #000000;">what</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">op</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">atom</span> <span style="color: #000000;">val</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">stuff</span><span style="color: #0000FF;">()</span>
<!--</
=={{header|PHP}}==
Every function returns one value. The conventional way to return multiple values is to bundle them into an array.
<
return array($x + $y, $x - $y);
}</
You can use the <code>list()</code> construct to assign to multiple variables:
<
echo "33 + 12 = $sum\n";
echo "33 - 12 = $difference\n";</
Additionally, if you specify a parameter as being a pointer, you do have the capacity to change that value. A built-in PHP example of this is <code>preg_match()</code> which returns a boolean value (to determine if a match was found or not), but which modifies the <code>$matches</code> parameter supplied to hold all the capture groups.
You can achieve this simply by adding the <code>&</code> before the desired parameter:
<
if ($param1 == 'bob') {
$param2 = 'is your grandmother';
Line 2,262 ⟶ 2,642:
echo 'Second run: ' . multiples('bob', $y) . "\r\n";
echo "Param 2 from second run: '${y}'\r\n";</
The above will yield the following output:
Line 2,273 ⟶ 2,653:
===Functions===
Functions returns a single value. Multiple values must be collected in a list (or an array, map, set, structure).
<
[A,B,C] = fun(10),
println([A,B,C]).
fun(N) = [2*N-1,2*N,2*N+1].</
===Predicates===
Sometimes it is not possible - or not convenient - to create a function that return values. In those cases a predicate is used and then some of the variables are considered output variables (and are usually placed last).
<
pred(10, E,F,G),
% ...
Line 2,289 ⟶ 2,669:
A=2*N-1,
B=2*N,
C=2*N+1.</
A variant of this is to use a structure (here <code>$ret(A,B,C)</code>) that collects the output values.
<
pred2(10, Ret),
println(Ret),
Line 2,303 ⟶ 2,683:
A=2*N-1,
B=2*N,
C=2*N+1.</
Note: Sometimes the meaning of input/output variables are confusing, for example when a predicate can be used with multiple input/output modes, e.g. reversible predicates such as <code>append/3</code> or <code>member/2</code>.
Line 2,311 ⟶ 2,691:
=={{header|PicoLisp}}==
A PicoLisp function returns a single value. For multiple return values, a cons pair or a list may be used.
<
(list (+ X Y) (- X Y)) )</
Test:
<
-> (6 2)
: (addsub 3 1)
Line 2,321 ⟶ 2,701:
-> 10
: (sum + (addsub 4 2) (addsub 3 1))
-> 14</
=={{header|Pike}}==
Multiple values are returned through an array.
An array can be assigned to separate variables.
<
{
return ({ x+y, x-y });
}
[int z, int w] = addsub(5,4);</
=={{header|PL/I}}==
Example 1 illustrates a function that returns an array:
<
2 a (10) float;
declare i fixed binary;
Line 2,346 ⟶ 2,726:
end;
return (p);
end sub;</
Example 2 illustrates a function that returns a general data structure:
<
2 name,
3 surname character (20),
Line 2,362 ⟶ 2,742:
get edit (c.street, c.suburb, c.zip) (L);
return (c);
end sub2;</
Example 3 illustrates the return of two values as a complex value:
<
declare (a, b) float;
return (complex(a, b) );
end comp;</
=={{header|Plain English}}==
Since parameters are passed by reference by default in Plain English, returning values ends up being unnecessary in most cases. The only functions that actually return a value are Boolean functions, called deciders.
It is possible, however, to call an auxiliary routine to change fields in a record and:
# Concatenate these values, assigning the concatenated string to a new string (see code below);
# Write the concatenated string on the console; or
# As is done in C style, obtain the address of the record (a pointer) and save the pointer's value in a number for later manipulation.
<syntaxhighlight line="1" start="1">The example record is a record with
A string called second field,
A flag called third field.
To run:
Start up.
Fill the example record.
Write the example record on the console.
Shut down.
To fill the example record:
Put 123 into the example's record's first field.
Put "Hello World!" into the example's record's second field.
Set the example's record's third field.
To Write the example record on the console:
Convert the example's example's record's first field to a string.
Convert the example's example's record's third field to another string.
Put the string then " "
then the example's record's second field
then " " then other string into a return string.
Write the return string on the console.
</syntaxhighlight>When it is necessary to get the return value from a Win 32 API function, the syntax is as follows:
''Call "dllname.dll" "FunctionNameHereIsCaseSensitive" returning a <type>.''
Example:s
''Call "gdi32.dll" "GetCurrentObject" with the printer canvas and 6 [obj_font] returning a handle.''
''Call "kernel32.dll" "SetFilePointer" with the file and 0 and 0 and 2 [file_end] returning a result number.''
''Call "kernel32.dll" "WriteFile" with the file and the buffer's first and the buffer's length and a number's whereabouts and 0 returning the result number.''
''Call "kernel32.dll" "HeapAlloc" with the heap pointer and 8 [heap_zero_memory] and the byte count returning the pointer.''{{out}}
<pre>
123 Hello World! yes
</pre>
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
function multiple-value ($a, $b) {
[pscustomobject]@{
Line 2,404 ⟶ 2,810:
$m.a
$m.b
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 2,415 ⟶ 2,821:
An array, map, or list can be used as a parameter to a procedure and in the process contain values to be returned as well. A pointer to memory or a structured variable may also be returned to reference multiple return values (requiring the memory to be manually freed afterwards).
<
;process contain values to be returned as well.
Procedure example_1(x, y, Array r(1)) ;array r() will contain the return values
Line 2,447 ⟶ 2,853:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
=={{header|Python}}==
Every function returns one value. The conventional way to return multiple values is to bundle them into a tuple.
<
return x + y, x - y</
(Note that parentheses are not necessary for a tuple literal in Python.)
You can assign to a comma-separated list of targets:
<
print "33 + 12 = %s" % sum
print "33 - 12 = %s" % difference</
There is no discernible difference between "returning multiple values" and returning a single tuple of multiple values. It is just a more pedantic/accurate statement of the mechanism employed.
Line 2,482 ⟶ 2,888:
=={{header|R}}==
The conventional way to return multiple values is to bundle them into a list.
<
=={{header|Racket}}==
Racket has a defined function "values" that returns multiple values using continuations, a way it can be implemented is shown in "my-values"
<
(values 4 5)
Line 2,492 ⟶ 2,898:
(call/cc
(lambda (return)
(apply return return-list))))</
=={{header|Raku}}==
Line 2,499 ⟶ 2,905:
Each function officially returns one value, but by returning a List or Seq you can transparently return a list of arbitrary (even infinite) size. The calling scope can destructure the list using assignment, if it so chooses:
<syntaxhighlight lang="raku"
$a + $b, $a * $b
}
my ($add, $mul) = addmul 3, 7;</
In this example, the variable <tt>$add</tt> now holds the number 10, and <tt>$mul</tt> the number 21.
=={{header|Raven}}==
<
$v each
3 multiReturn</
{{out}}
<pre>2
Line 2,518 ⟶ 2,924:
=={{header|ReScript}}==
<
(x + y, x - y)
}
Line 2,525 ⟶ 2,931:
Js.log2("33 + 12 = ", sum)
Js.log2("33 - 12 = ", difference)</
=={{header|Retro}}==
Functions take and return values via a stack. This makes returning multiple values easy.
<
2over - [ + ] dip ;</
=={{header|REXX}}==
Line 2,539 ⟶ 2,945:
<br>semicolon, backslash, ···], it's a very simple matter to parse the multiple-value string into the desired
<br>substrings (or values, if you will) with REXX's handy-dandy '''parse''' statement.
<
numeric digits 70 /*the default is: NUMERIC DIGITS 9 */
parse arg a b . /*obtain two numbers from command line.*/
Line 2,559 ⟶ 2,965:
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
arithmetics: procedure; parse arg x,y; return x||y x+y x-y x//y x/y x%y x*y x**y</
{{out|output|text= when using the default inputs:}}
<pre>
Line 2,576 ⟶ 2,982:
=={{header|Ring}}==
<
Func AddSub x,y
Return [ x+y, x-y ]
</syntaxhighlight>
=={{header|RPL}}==
The stack is where data are taken and then returned: stack size's the limit!
≪ + LAST - ≫ ‘ADDSUB’ STO
{{in}}
<pre>
33 12 ADDSUB
</pre>
{{out}}
<pre>
2: 44
1: 20
</pre>
=={{header|Ruby}}==
Line 2,585 ⟶ 3,004:
Use an array literal:
<
[x + y, x - y]
end</
Or use <code>return</code> with 2 or more values:
<
return x + y, x - y
end</
(With at least 2 values, <code>return</code> makes a new Array. With 1 value, <code>return</code> passes the value, without making any Array. With 0 values, <code>return</code> passes <code>nil</code>.)
Assignment can split the Array into separate variables.
<
puts "33 + 12 = #{sum}"
puts "33 - 12 = #{difference}"</
=={{header|Run BASIC}}==
Courtesy http://dkokenge.com/rbp
<br>Gets the UTC time from the web
<
print " UTC:";word$(a$,1,"|")
print "Date:";word$(a$,2,"|")
Line 2,613 ⟶ 3,032:
t$ = time$()
timeInfo$ = utc$;"|";d$;"|";t$
end function</
=={{header|Rust}}==
Line 2,619 ⟶ 3,038:
Rust supports ADT, thus function can return tuple.
<
("Hello",42)
}
Line 2,627 ⟶ 3,046:
println!("{},{}",str,num);
}
</syntaxhighlight>
{{out}}
Line 2,636 ⟶ 3,055:
=={{header|Scala}}==
Every function returns one value. The conventional way to return multiple values is to return a tuple.
<
A more detailed declaration would be:
<
def addSubMult(x: Int, y:Int) : (Int, Int, Int) = {
...
(x + y, x - y, x * y)
}
</syntaxhighlight>
You can use pattern matching to extract the components:
<
Scala borrows this idea from ML, and generalizes it into [http://www.scala-lang.org/node/112 extractors].
=={{header|Scheme}}==
Scheme can return multiple values using the <code>values</code> function, which uses continuations:
<
(values (+ x y) (- x y)))</
You can use the multiple values using the <code>call-with-values</code> function:
<
(lambda () (addsub 33 12))
(lambda (sum difference)
(display "33 + 12 = ") (display sum) (newline)
(display "33 - 12 = ") (display difference) (newline)))</
The syntax is kinda awkward. SRFI 8 introduces a <code>receive</code> construct to make this simpler:
<
; in this scope you can use sum and difference
(display "33 + 12 = ") (display sum) (newline)
(display "33 - 12 = ") (display difference) (newline))</
SRFI 11 introduces a <code>let-values</code> construct to make this simpler:
<
; in this scope you can use sum and difference
(display "33 + 12 = ") (display sum) (newline)
(display "33 - 12 = ") (display difference) (newline))</
=={{header|Seed7}}==
Seed7 functions can only return one value. That value could be an array or record holding multiple values, but the usual method for returning several values is using a procedure with [http://seed7.sourceforge.net/manual/params.htm#inout_parameter inout] parameters:
<
const proc: sumAndDiff (in integer: x, in integer: y, inout integer: sum, inout integer: diff) is func
Line 2,687 ⟶ 3,106:
writeln("Sum: " <& sum);
writeln("Diff: " <& diff);
end func;</
{{out}}
Line 2,697 ⟶ 3,116:
=={{header|SenseTalk}}==
You can return multiple values in SenseTalk by returning a list, which can be assigned to multiple variables.
<
put !"The quotient of 13 ÷ 4 is: [[quotient]] with remainder: [[remainder]]"
Line 2,703 ⟶ 3,122:
to handle quotientAndRemainder of num, divisor
return [num div divisor, num rem divisor]
end quotientAndRemainder</
{{out}}
<pre>
Line 2,710 ⟶ 3,129:
=={{header|Sidef}}==
<
return (a+b, a*b);
}</
Catching the returned arguments:
<
say x; #=> 9
say y; #=> 20</
=={{header|Smalltalk}}==
Line 2,723 ⟶ 3,142:
Smalltalk returns a single value from methods, so this task is usually implemented the scheme-way, by passing a lambda-closure which is invoked with the values to return and either operates on the values itself or sets them as the caller's locals (i.e. simular to call-with-values ... values):
<
Transcript show:a; cr.
Transcript show:b; cr.
]</
or:
<
foo multipleValuesInto:[:a :b |
val1 := a.
Line 2,735 ⟶ 3,154:
].
... do something with val1 and val2...
</syntaxhighlight>
The called method in foo looks like:
<
multipleValuesInto: aTwoArgBlock
...
aTwoArgBlock value:<value1> value:<value2>
</syntaxhighlight>
i.e. it invokes the passed-in lambda closure with the two (return-)values.
=={{header|Standard ML}}==
Every function returns one value. The conventional way to return multiple values is to return a tuple.
<
(x + y, x - y)</
You can use pattern matching to extract the components:
<
val (sum, difference) = addsub (33, 12)
in
print ("33 + 12 = " ^ Int.toString sum ^ "\n");
print ("33 - 12 = " ^ Int.toString difference ^ "\n")
end</
=={{header|Swift}}==
Every function returns one value. The conventional way to return multiple values is to bundle them into a tuple.
<
return (x + y, x - y)
}</
You can use pattern matching to extract the components:
<
println("33 + 12 = \(sum)")
println("33 - 12 = \(difference)")</
=={{header|Tcl}}==
Tcl commands all return a single value, but this value can be a compound value such as a list or dictionary. The result value of a procedure is either the value given to the <code>return</code> command or the result of the final command in the body in the procedure. (Commands that return “no” value actually return the empty string.)
<
list [expr {$x+$y}] [expr {$x-$y}]
}</
This can be then assigned to a single variable with <code>set</code> or to multiple variables with <code>lassign</code>.
<
puts "33 + 12 = $sum, 33 - 12 = $difference"</
=={{header|TXR}}==
Line 2,780 ⟶ 3,199:
The following function potentially returns three values, which will happen if called with three arguments, each of which is an unbound variable:
<
@ (bind w "discarded")
@ (bind (x y z) ("a" "b" "c"))
@(end)</
The binding <code>w</code>, if created, is discarded because <code>w</code> is not in the list of formal parameters. However, <code>w</code> can cause the function to fail because there can already exist a variable <code>w</code> with a value which doesn't match <code>"discarded"</code>.
Call:
<syntaxhighlight lang
If <code>t</code>, <code>r</code> and <code>s</code> are unbound variables, they get bound to <code>"a"</code>, <code>"b"</code> and <code>"c"</code>, respectively via a renaming mechanism. This may look like C++ reference parameters or Pascal "var" parameters, and can be used that way, but isn't really the same at all.
Failed call ("1" doesn't match "a"):
<
Successful call binding only one new variable:
<
=={{header|UNIX Shell}}==
Line 2,799 ⟶ 3,218:
it can be simulated through some clunky code.
<
#!/bin/sh
funct1() {
Line 2,814 ⟶ 3,233:
echo "x=$x"
echo "y=$y"
</syntaxhighlight>
{{out}}
Line 2,826 ⟶ 3,245:
This example gets a specified amount of strings from the user, then returns a stream containing them.
<
decl string<> input
Line 2,845 ⟶ 3,264:
set ret (getstrs amount)
out endl ret endl console</
{{out}}
<pre>how many strings do you want to enter? 5
Line 2,858 ⟶ 3,277:
=={{header|VBA}}==
Firt way : User Defined Type
<syntaxhighlight lang="vb">
Type Contact
Name As String
Line 2,878 ⟶ 3,297:
Debug.Print Cont.Name & " " & Cont.firstname & ", " & Cont.Age & " years old."
End Sub
</syntaxhighlight>
{{out}}
<pre>SMITH John, 23 years old.</pre>
Second way : ByRef argument : (Note : the ByRef Arg could be an array)
<syntaxhighlight lang="vb">
Function Divide(Dividend As Integer, Divisor As Integer, ByRef Result As Double) As Boolean
Divide = True
Line 2,904 ⟶ 3,323:
Debug.Print "Divide return : " & B & " Result = " & R
End Sub
</syntaxhighlight>
{{out}}
<pre>Divide return : True Result = 3,33333333333333
Divide return : False Result = 1,#INF</pre>
Third way : ParramArray
<syntaxhighlight lang="vb">
Function Multiple_Divide(Dividend As Integer, Divisor As Integer, ParamArray numbers() As Variant) As Long
Dim i As Integer
Line 2,944 ⟶ 3,363:
Next i
End Sub
</syntaxhighlight>
{{out}}
<pre>The function return : 1
Line 2,960 ⟶ 3,379:
vbNullString</pre>
Fourth way : the variant() function
<syntaxhighlight lang="vb">
Function List() As String()
Dim i&, Temp(9) As String
Line 2,979 ⟶ 3,398:
Next
End Sub
</syntaxhighlight>
{{out}}
<pre>Liste 1
Line 2,993 ⟶ 3,412:
=={{header|Visual FoxPro}}==
<
*!* Return multiple values from a function
*!* The simplest way is to pass the parameters by reference
Line 3,011 ⟶ 3,430:
RETURN n
ENDFUNC
</syntaxhighlight>
=={{header|Wren}}==
In Wren, one would return multiple values from a function or method by using some sort of Sequence object, usually a List though a Map could be used if you needed ''named'' returns.
<
var names = splitName.call("George Bernard Shaw")
System.print("First name: %(names[0]), middle name: %(names[1]) and surname: %(names[2]).")</
{{out}}
Line 3,026 ⟶ 3,445:
=={{header|XPL0}}==
<
proc Rect2Polar(X,Y,A,D); \Return two polar coordinate values
Line 3,039 ⟶ 3,458:
RlOut(0, Dist);
CrLf(0);
]</
{{out}} (angle is in radians):
Line 3,050 ⟶ 3,469:
In this trivial example, the function returns 0xABCD and 0xFFFF.
<
ld hl,&ABCD
ld bc,&FFFF
ret</
=={{header|zkl}}==
<
a,b,c:=f() // a==1, b==2, c=="three"</
|