Return multiple values: Difference between revisions

{{trans|Python}}

 

R (x + y, x - y)

 

V (summ, difference) = addsub(33, 12)

print(‘33 + 12 = ’summ)

 

{{out}}

33 - 12 = 21

</pre>

 

=={{header|ACL2}}==

(defun multiple-values (a b)

(mv a b))

(mv-let (x y)

(multiple-values 1 2)

<br><br>

 

=={{header|Ada}}==

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.

with Ada.Text_IO; use Ada.Text_IO;

procedure MultiReturn is

Put_Line ("Diff:" & Integer'Image (thediff));

end MultiReturn;

{{out}}

<pre>

<br>

Tested with Agena 2.9.5 Win32

mv := proc() is

return 1, 2, "three"

local a, b, c := mv();

print( c, b, a )

 

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

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

 

# access the components separately #

print( ( name OF get pair( 1 ), value OF get pair( 2 ), newline ) )

{{out}}

<pre>

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

end

 

 

 

=={{header|Arturo}}==

@[x+y x-y]

 

 

print [a "+" b "=" result\0]

 

{{out}}

=={{header|ATS}}==

Every function returns one value. The conventional way to return multiple values is to return a tuple.

#include

"share/atspre_staload.hats"

println! ("33 + 12 = ", sum);

println! ("33 - 12 = ", diff);

 

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

Func _AddSub($iX, $iY)

Local $aReturn[2]

Return $aReturn

EndFunc

 

=={{header|BASIC}}==

==={{header|BaCon}}===

BaCon can return homogeneous dynamic arrays, or RECORD data holding heterogeneous types.

 

RECORD multi

LOCAL num

PRINT rec.num

PRINT rec.s$[0]

 

{{out}}

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

c = a + b

d = a - b

 

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

110 CALL SUMDIFF(5,3,SUM,DIFF)

120 PRINT "Sum is";SUM:PRINT "Difference is";DIFF

140 DEF SUMDIFF(A,B,REF C,REF D)

150 LET C=A+B:LET D=A-B

 

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

=={{header|C}}==

C has structures which can hold multiple data elements of varying types.

 

typedef struct{

 

return 0;

{{out}}

<pre>

 

C99 and above also allow structure literals to refer to the name, rather than position, of the element to be initialized:

 

typedef struct {

printf("The name's %s. %s %s.\n", me.last, me.first, me.last);

return 0;

{{out}}

<pre>The name's Bond. James Bond.

 

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

using System.Collections.Generic;

using System.Linq;

min = sortedNums.First();

}

{{out}}

<pre>Min: -3

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

Since C++11, the C++-standard-library includes tuples, as well as an easy way to destructure them.

#include <array>

#include <cstdint>

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>

Every function returns one value.

The conventional way to return multiple values is to bundle them into an array.

 

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

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

(let [{:keys [q r]} (quot-rem 11 3)]

(println q)

 

=={{header|CMake}}==

function(firstlast string first last)

# f = first character.

 

firstlast("Rosetta Code" begin end)

 

=={{header|COBOL}}==

{{works with|GnuCOBOL}}

 

identification division.

program-id. multiple-values.

goback.

end function multiples.

 

{{out}}

 

Returning a single value is accomplished by evaluating an expression (which itself yields a single value) at the end of a body of forms.

The next possibility is that of returning no values at all. For this, the <code>values</code> function is used, with no arguments:

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

10

[5]> (multiple-value-call #'+ (add-sub 4 2) (add-sub 3 1)) ; 6+2+4+2

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

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:

 

4. Assignment to variables:

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

 

print("Min: "); print_i8(least); print_nl();

 

{{out}}

 

=={{header|D}}==

 

 

 

writefln("33 + 12 = %d\n33 - 12 = %d", a, b);

{{out}}

<pre>33 + 12 = 45

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

{{out}}

<pre>35

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

Writeln(x);

Writeln(y);

 

=={{header|Dyalect}}==

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

{{out}}

<pre>10

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

(plus-minus 3 4)

→ (7 -1)

 

=={{header|ECL}}==

RetMod := MODULE

EXPORT INTEGER Add := i1 + i2;

MyFunc(3,4).Add;

MyFunc(3,4).Prod;

 

=={{header|Eiffel}}==

Every function returns one value. Multiple values can be returned in a tuple.

do

Result := [1, 'j', "r"]

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

Result := [1, 'j', "r"] -- okay

Result := [1, 'j', "r", 1.23] -- also okay

 

=={{header|Elena}}==

import extensions;

console.printLine("Min: ",min," Max: ",max)

{{out}}

<pre>

=={{header|Elixir}}==

Elixir returns in the tuple form when returning more than one value.

def addsub(a, b) do

{a+b, a-b}

 

{add, sub} = RC.addsub(7, 4)

 

{{out}}

 

=={{header|Erlang}}==

 

-module(return_multi).

multiply(A, B) ->

{A * B, A + B, A - B}.

{{out}}

<pre>12 7 -1

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

PROGRAM RETURN_VALUES

 

PRINT("Difference is";DIFF)

END PROGRAM

 

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

result = addmultret(aWholeNumber, aFloat, aSequence) --call function, assign what it gets into result - {9.999999, 23.999988}

? result

 

{{out}}

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

 

Output parameters from .NET APIs are automatically converted to tuples by the compiler.

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

 

 

[ "15 * 3 = " write . ]

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

 

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

 

=={{header|Fortran}}==

{{trans|Haskell}}

implicit none

type res

print *, addsub(33, 22)

end program

 

=={{header|FreeBASIC}}==

 

' One way to return multiple values is to use ByRef parameters for the additional one(s)

Print

Print "Press any key to quit"

 

{{out}}

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

 

=={{header|FunL}}==

{{trans|Scala}}

 

val (sum, difference) = addsub( 33, 12 )

 

 

{{out}}

 

Here is an example of returning multiple values using pointers:

local fn ReturnMultipleValues( strIn as Str255, strOut as ^Str255, letterCount as ^long )

end fn

 

 

fn ReturnMultipleValues( "Hello, World!", @outStr, @outCount )

 

Output:

 

Another way to pass multiple values from a function is with records (AKA structures):

// Elements in global array

_maxDim = 3

 

begin record Addresses

end record

 

begin globals

end globals

 

local fn FillRecord( array(_maxDim) as Addresses )

end fn

 

fn FillRecord( gAddressData(0) )

 

for i = 0 to 2

next

 

Output:

 

You can also use global arrays to return multiple values from a function as in this example:

// Elements in global array

_maxDim = 3

 

begin globals

end globals

 

array( 0, 0 ) = "John Doe"

array( 1, 0 ) = "Mary Jones"

 

array( 0, 1 ) = "555-359-4411"

fn FillRecord( gAddressArray( 0, 0 ) )

 

 

for i = 0 to 2

next

 

Output:

 

Here is another example using FB's containers -- bit buckets that can hold up to 2GB of data contingent on system memory.

begin globals

// An FB container can hold up to 2GB of data, contingent on system memory

end globals

 

// Check the new results

print gC1 : print gC2

 

Output:

=={{header|Fōrmulæ}}==

 

 

 

 

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

 

import (

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:

 

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 ]

}

def (sum, diff) = addSub2(50, 5)

assert sum == 55

 

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.

=={{header|Harbour}}==

Every function returns one value. The conventional way to return multiple values is to bundle them into an array.

 

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

 

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

 

The following examples return 1, 2, 3 in different ways:

return [1,2,3]

end

procedure retRecord() # return as a record, least general method

return retdata(1,2,3)

 

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

 

=={{header|Java}}==

{{trans|NetRexx}}

import java.util.ArrayList;

import java.util.Map;

}

}

'''Otherwise'''

private final Object[] objects;

public Values(Object ... objects) {

System.out.println();

}

{{out}}

<pre>

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

var {baz: foo, buz: bar} = objBind();//assigns baz => "abc", buz => "123"

//keep rest of values together as object

 

=={{header|jq}}==

def addsub(x; y): (x + y), (x - y);

 

# To produce an array:

def add_subtract(x; y): [ x+y, x-y ];

1

 

=={{header|Julia}}==

return x + y, x - y

<pre>julia> addsub(10,4)

(14,6)</pre>

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

println("The smallest number is $min")

println("The largest number is $max")

 

{{out}}

=={{header|Lambdatalk}}==

Lambdatalk can retun several values glued into conses or arrays.

{def foo

{lambda {:n}

{bar 10}

-> [9,10,11]

 

=={{header|Lasso}}==

return (:'hello word',date)

}

 

'x: '+#x

{{out}}

<pre>x: hello word

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

loop until 0

minMax$ =str$( min) +" " +str$( max)

<pre>

Minimum was -5 & maximum was 22

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 )

 

=={{header|Maple}}==

> sumprod( x, y );

x + y, x y

 

> sumprod( 2, 3 );

The parentheses are needed here only because of the use of arrow ("->") notation to define the procedure. One could do, instead:

 

{{out}}

<pre>{6,2}</pre>

 

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

a = 1-d;

b = 2+d;

c = a+b;

end;

{{out}}

x = -4

y = 7

 

=={{header|Maxima}}==

 

[u, v]: f(5, 6);

 

=={{header|Mercury}}==

 

===addsub.m===

 

:- interface.

D = X - Y.

 

 

===Use and output===

The above code can be modified so that the definition of <code>addsub/4</code> is now instead this function <code>addsub/2</code>:

 

 

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.

An example of this follows:

 

 

:- interface.

addsub(X, Y) = twin(X + Y, X - Y).

 

 

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.

To return multiple values in min, simply leave them on the data stack.

{{works with|min|0.19.6}}

 

=={{header|Nemerle}}==

To return multiple values in Nemerle, package them into a tuple.

using System.Console;

using Nemerle.Assertions;

WriteLine($"Min of nums = $min; max of nums = $max");

}

 

=={{header|NetRexx}}==

 

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

 

setRightVal(sv_)

return

 

=={{header|Nim}}==

Every function returns one value. We can return a tuple instead:

(x + y, x - y)

 

 

Or manipulate the parameters directly:

a = x + y

b = x - y

 

var a, b: int

 

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

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.

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

 

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

 

"\nShowing one object containing four values returned on the parameter stack:" println

 

Output:

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

r = addsub(3, 4)

say r[1] r[2]

use arg x, y

return .array~of(x + y, x - y)

Output:

<pre>

Demonstrated with vectors, using OOP and a pseudo-assign trick:

 

 

'============

print aa.ShowValues() 'result 100,200,-300,400

 

 

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

 

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

 

echo 'Second run: ' . multiples('bob', $y) . "\r\n";

 

The above will yield the following output:

Second run: 1

Param 2 from second run: 'is your grandmother'</pre>

 

=={{header|PicoLisp}}==

A PicoLisp function returns a single value. For multiple return values, a cons pair or a list may be used.

Test:

-> (6 2)

: (addsub 3 1)

-> 10

: (sum + (addsub 4 2) (addsub 3 1))

 

=={{header|Pike}}==

Multiple values are returned through an array.

An array can be assigned to separate variables.

{

return ({ x+y, x-y });

}

 

 

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

Example 1 illustrates a function that returns an array:

2 a (10) float;

declare i fixed binary;

end;

return (p);

Example 2 illustrates a function that returns a general data structure:

2 name,

3 surname character (20),

get edit (c.street, c.suburb, c.zip) (L);

return (c);

Example 3 illustrates the return of two values as a complex value:

declare (a, b) float;

 

return (complex(a, b) );

 

=={{header|Plain English}}==

 

 

 

<pre>

</pre>

 

=={{header|PowerShell}}==

function multiple-value ($a, $b) {

[pscustomobject]@{

$m.a

$m.b

<b>Output:</b>

<pre>

 

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

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

 

=={{header|Python}}==

Every function returns one value. The conventional way to return multiple values is to bundle them into a tuple.

(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

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.

 

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

 

(call/cc

(lambda (return)

 

=={{header|Raku}}==

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:

 

$a + $b, $a * $b

}

 

 

In this example, the variable <tt>$add</tt> now holds the number 10, and <tt>$mul</tt> the number 21.

 

=={{header|Raven}}==

$v each

 

{{out}}

<pre>2

1

0</pre>

 

=={{header|Retro}}==

Functions take and return values via a stack. This makes returning multiple values easy.

 

=={{header|REXX}}==

<br>semicolon, backslash, ···], &nbsp; it's a very simple matter to parse the multiple-value string into the desired

<br>substrings &nbsp; (or values, if you will) &nbsp; with REXX's handy-dandy &nbsp; '''parse''' &nbsp; statement.

numeric digits 70 /*the default is: NUMERIC DIGITS 9 */

parse arg a b . /*obtain two numbers from command line.*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

Func AddSub x,y

Return [ x+y, x-y ]

 

=={{header|Ruby}}==

 

Use an array literal:

[x + y, x - y]

Or use <code>return</code> with 2 or more values:

return x + y, x - y

 

(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}"

 

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

t$ = time$()

timeInfo$ = utc$;"|";d$;"|";t$

 

=={{header|Rust}}==

Rust supports ADT, thus function can return tuple.

 

("Hello",42)

}

println!("{},{}",str,num);

}

 

{{out}}

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

}

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:

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)

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)

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)

 

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

writeln("Sum: " <& sum);

writeln("Diff: " <& diff);

 

{{out}}

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

to handle quotientAndRemainder of num, divisor

return [num div divisor, num rem divisor]

{{out}}

<pre>

 

=={{header|Sidef}}==

return (a+b, a*b);

 

Catching the returned arguments:

say x; #=> 9

 

=={{header|Smalltalk}}==

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.

].

... do something with val1 and val2...

 

The called method in foo looks like:

multipleValuesInto: aTwoArgBlock

...

aTwoArgBlock value:<value1> value:<value2>

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.

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

 

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

 

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

 

=={{header|TXR}}==

 

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

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:

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

it can be simulated through some clunky code.

 

#!/bin/sh

funct1() {

echo "x=$x"

echo "y=$y"

 

{{out}}

 

This example gets a specified amount of strings from the user, then returns a stream containing them.

decl string<> input

 

set ret (getstrs amount)

 

{{out}}

<pre>how many strings do you want to enter? 5

=={{header|VBA}}==

Firt way : User Defined Type

Type Contact

Name As String

Debug.Print Cont.Name & " " & Cont.firstname & ", " & Cont.Age & " years old."

End Sub

{{out}}

<pre>SMITH John, 23 years old.</pre>

Second way : ByRef argument : (Note : the ByRef Arg could be an array)

Function Divide(Dividend As Integer, Divisor As Integer, ByRef Result As Double) As Boolean

Divide = True

Debug.Print "Divide return : " & B & " Result = " & R

End Sub

{{out}}

<pre>Divide return : True Result = 3,33333333333333

Divide return : False Result = 1,#INF</pre>

Third way : ParramArray

Function Multiple_Divide(Dividend As Integer, Divisor As Integer, ParamArray numbers() As Variant) As Long

Dim i As Integer

Next i

End Sub

{{out}}

<pre>The function return : 1

vbNullString</pre>

Fourth way : the variant() function

Function List() As String()

Dim i&, Temp(9) As String

Next

End Sub

{{out}}

<pre>Liste 1

 

=={{header|Visual FoxPro}}==

*!* Return multiple values from a function

*!* The simplest way is to pass the parameters by reference

RETURN n

ENDFUNC

 

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

 

{{out}}

 

=={{header|XPL0}}==

 

proc Rect2Polar(X,Y,A,D); \Return two polar coordinate values

RlOut(0, Dist);

CrLf(0);

 

{{out}} (angle is in radians):

0.64350 5.00000

</pre>

 

=={{header|zkl}}==