Return multiple values: Difference between revisions

Show how to return more than one value from a function.

 

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

 

 

 

& out$("33 + 12 = " !sum)

& out$("33 - 12 = " !difference)

 

 

typedef struct{

double bigDecimal;

}Composite;

 

Composite example()

{

return C;

}

 

{

Composite C = example();

return 0;

Values from a function returning a structure : { 1, 2.300000, a, Hello World, 45.678000}

 

 

 

}

 

 

using System.Collections.Generic;

using System.Linq;

 

{

{

 

}

 

<pre>Min: -3

Max: 51</pre>

 

 

 

 

 

 

 

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

auto addSub(T)(T x, T y) {

return tuple(x + y, x - y);

}

void main() {

<pre>33 + 12 = 45

33 - 12 = 21</pre>

 

 

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

 

 

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

 

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

]

}

 

 

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

 

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

Icon and Unicon values range from simple atomic values like integers and strings to structures like lists, tables, sets, records. The contents of structures are heterogeneous and any of them could be used to return multiple values all at once. Additionally, generators are supported that return multiple results one at a time as needed.

 

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

 

 

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

</pre>

=={{header|Lua}}==

return a+b, a-b

end

 

s, d = addsub( 7, 5 )

 

 

 

a = 1-d;

b = 2+d;

c = a+b;

end;

x = -4

y = 7

 

=={{header|Mercury}}==

 

===addsub.m===

 

:- interface.

 

main(!IO) :-

addsub(X, Y, S, D),

;

).

 

addsub(X, Y, S, D) :-

S = X + Y,

 

===Use and output===

100 - 999 = -899</nowiki></pre>

 

 

 

(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|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) = @_;

 

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

 

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

{

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

</pre>

=={{header|PureBasic}}==

PureBasic's procedures return only a single value. The value needs to be a standard numeric type or string.

 

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

 

 

=={{header|R}}==

The conventional way to return multiple values is to bundle them into a list.

 

 

=={{header|Retro}}==

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

 

 

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

 

 

 

 

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

in

print ("33 + 12 = " ^ Int.toString sum ^ "\n");

print ("33 - 12 = " ^ Int.toString difference ^ "\n")

 

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

TXR functions return material by binding unbound variables.

 

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