Return multiple values

From Rosetta Code
Revision as of 18:05, 14 December 2013 by rosettacode>MathiasVP (Undo revision 172860 by MathiasVP (talk))
Task
Return multiple values
You are encouraged to solve this task according to the task description, using any language you may know.

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

ACL2

<lang Lisp>;; To return multiple values: (defun multiple-values (a b)

  (mv a b))
To extract the values

(mv-let (x y)

       (multiple-values 1 2)
  (+ x y))</lang>

Ada

Ada functions can only return one type. That type could be an array or record holding multiple values, but the usual method for returning several values is using 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. <lang Ada> with Ada.Text_IO; use Ada.Text_IO; procedure MultiReturn is

  procedure SumAndDiff (x, y : Integer; sum, diff : out Integer) is begin
     sum := x + y;
     diff := x - y;
  end SumAndDiff;
  inta : Integer := 5;
  intb : Integer := 3;
  thesum, thediff : Integer;

begin

  SumAndDiff (inta, intb, thesum, thediff);
  Put_Line ("Sum:" & Integer'Image (thesum));
  Put_Line ("Diff:" & Integer'Image (thediff));

end MultiReturn; </lang>

Output:
Sum: 8
Diff: 2

ATS

Every function returns one value. The conventional way to return multiple values is to return a tuple. <lang ATS>fn addsub (x: int, y: int): (int, int) =

 (x+y, x-y)

implement main () = let

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

in

 print! ("33 + 12 = ", sum, "\n");
 print! ("33 - 12 = ", diff, "\n")

end</lang>

AutoHotkey

Works with: AutoHotkey_L

Functions may return one value. The conventional way to return multiple values is to bundle them into an Array. <lang AutoHotkey>addsub(x, y) {

 return [x + y, x - y]

}</lang>

AutoIt

Return an array. <lang AutoIt> Func _AddSub($iX, $iY) Local $aReturn[2] $aReturn[0] = $iX + $iY $aReturn[1] = $iX - $iY Return $aReturn EndFunc </lang>

BBC BASIC

The most straightforward way of returning multiple values is to specify them as RETURNed parameters. <lang bbcbasic> PROCsumdiff(5, 3, sum, diff)

     PRINT "Sum is " ; sum
     PRINT "Difference is " ; diff
     END
     
     DEF PROCsumdiff(a, b, RETURN c, RETURN d)
     c = a + b
     d = a - b
     ENDPROC</lang>

Bracmat

Translation of: Haskell

Every function returns one value. The conventional way to return multiple values is to return a tuple. <lang bracmat>(addsub=x y.!arg:(?x.?y)&(!x+!y.!x+-1*!y));</lang> You can use pattern matching to extract the components: <lang bracmat>( addsub$(33.12):(?sum.?difference) & out$("33 + 12 = " !sum) & out$("33 - 12 = " !difference) );</lang> Output:

33 + 12 =  45
33 - 12 =  21

C

C has structures which can hold multiple data elements of varying types. <lang c>#include<stdio.h>

typedef struct{ int integer; float decimal; char letter; char string[100]; double bigDecimal; }Composite;

Composite example() { Composite C = {1, 2.3, 'a', "Hello World", 45.678}; return C; }


int main() { Composite C = example();

printf("Values from a function returning a structure : { %d, %f, %c, %s, %f}\n", C.integer, C.decimal, C.letter, C.string, C.bigDecimal);

return 0; }</lang> Output:

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

C99 and above also allow structure literals to refer to the name, rather than position, of the element to be initialized: <lang c>#include <stdio.h>

typedef struct {

   char *first, *last;

} Name;

Name whatsMyName() {

   return (Name) {
       .first = "James",
       .last = "Bond",
   };

}

int main() {

   Name me = whatsMyName();
   printf("The name's %s. %s %s.\n", me.last, me.first, me.last);
   return 0;

}</lang> Output:

The name's Bond. James Bond.

C++

The new 2011 C++ standard includes tuples, which allow a number of different values of even different types to be passed around. <lang cpp>#include <algorithm>

  1. include <iostream>
  2. include <tr1/tuple>

std::tr1::tuple<const int , const int> minmax ( const int * numbers , const int num ) {

  const int *maximum = std::max_element ( numbers , numbers + num ) ;
  const int *minimum = std::min_element ( numbers , numbers + num ) ;
  std::tr1::tuple<const int , const int> result( *maximum , *minimum ) ;
  return result ;

}

int main( ) {

  const int numbers[ ] = { 17 , 88 , 9 , 33 , 4 , 987 , -10 , 2 } ;
  int numbersize = sizeof( numbers ) / sizeof ( int ) ;
  std::tr1::tuple<const int , const int> result = minmax( numbers , numbersize ) ;
  std::cout << "The greatest number is " << std::tr1::get<0>( result ) 
     << " , the smallest " << std::tr1::get<1>( result ) << " !\n" ;
  return 0 ;

}</lang> Output:

The greatest number is 987 , the smallest -10 !

C#

<lang c sharp>using System; using System.Collections.Generic; using System.Linq;

namespace ReturnMultipleValues {

   internal class Program
   {
      static void Main()
      {
          var minMax = MinMaxNum(new[] {4, 51, 1, -3, 3, 6, 8, 26, 2, 4});
          int min = minMax.Item1;
          int max = minMax.Item2;
          Console.WriteLine("Min: {0}\nMax: {1}", min, max);
      }
       static Tuple<int,int> MinMaxNum(IEnumerable<int> nums)
       {
           var sortedNums = nums.OrderBy(num => num).ToArray();
           return new Tuple<int, int>(sortedNums.First(), sortedNums.Last());
       }
   }

}</lang> Output

Min: -3
Max: 51

Clipper

Every function returns one value. The conventional way to return multiple values is to bundle them into an array. <lang Clipper>Function Addsub( x, y ) Return { x+y, x-y }</lang>

Clojure

Multiple values can be returned by packaging them in a vector. At receiving side, these arguments can be obtained individually by using destructuring. <lang clojure>(defn quot-rem [m n] [(quot m n) (rem m n)])

The following prints 3 2.

(let [[q r] (quot-rem 11 3)]

 (println q)
 (println r))</lang> 

In complex cases, it would make more sense to return a map, which can be destructed in a similar manner. <lang clojure>(defn quot-rem [m n]

 {:q (quot m n)
  :r (rem m n)})
The following prints 3 2.

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

 (println q)
 (println r))</lang>

CMake

<lang cmake># Returns the first and last characters of string. function(firstlast string first last)

 # f = first character.
 string(SUBSTRING "${string}" 0 1 f)
 # g = last character.
 string(LENGTH "${string}" length)
 math(EXPR index "${length} - 1")
 string(SUBSTRING "${string}" ${index} 1 g)
 # Return both characters.
 set("${first}" "${f}" PARENT_SCOPE)
 set("${last}" "${g}" PARENT_SCOPE)

endfunction(firstlast)

firstlast("Rosetta Code" begin end) message(STATUS "begins with ${begin}, ends with ${end}")</lang>

Common Lisp

Besides the obvious method of passing around a list, Common Lisp also allows a function to return multiple values. When citing the return values, if no interest is shown for multiple values, only the first (the primary return value) is used. Multiple values are not a data structure such as a tuple, list or array. They are a true mechanism for returning multiple values.

Returning a single value is accomplished by evaluating an expression (which itself yields a single value) at the end of a body of forms. <lang lisp>(defun return-three ()

 3)</lang>

The next possibility is that of returning no values at all. For this, the values function is used, with no arguments: <lang lisp>(defun return-nothing ()

 (values))</lang>

To combine the values of multiple expressions into a multi-value return, values is used with arguments. The following is from an interactive CLISP session. CLISP's listener shows multiple values separated by a semicolon: <lang lisp>[1]> (defun add-sub (x y) (values-list (list (+ x y) (- x y)))) ADD-SUB [2]> (add-sub 4 2)  ; 6 (primary) and 2 6 ; 2 [3]> (add-sub 3 1)  ; 4 (primary) and 2 4 ; 2 [4]> (+ (add-sub 4 2) (add-sub 3 1))  ; 6 + 4 10 [5]> (multiple-value-call #'+ (add-sub 4 2) (add-sub 3 1)) ; 6+2+4+2 14</lang> What happens if something tries to use the value of a form which returned (values)? In this case the behavior defaults to taking the value nil: <lang lisp>(car (values)) ;; no error: same as (car nil)</lang> What if the values 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 nil for any expression which did not yield a value: <lang lisp>(values (values 1 2 3) (values) 'a)</lang> yields three values:

-> 1; NIL; A

This also means that values can be used to reduce a multiple value to a single value: <lang lisp>;; return exactly one value, no matter how many expr returns,

nil if expr returns no values

(values expr)</lang> Multiple values are extracted in several ways.

1. Binding to variables: <lang lisp>(multiple-value-bind (dividend remainder) (truncate 16 3)

 ;; in this scope dividend is 5; remainder is 1
 )</lang>

2. Conversion to a list: <lang lisp>(multiple-value-list (truncate 16 3)) ;; yields (5 1)</lang>

3. Reification of multiple values as arguments to another function: <lang lisp>;; pass arguments 5 1 to +, resulting in 6: (multiple-value-call #'+ (truncate 16 3))</lang>

4. Assignment to variables: <lang lisp>;; assign 5 to dividend, 1 to remainder: (multiple-value-setq (dividend remainder) (truncate 16 1))</lang> (values ...) syntax is treated as a multiple value place by setf and other operators, allowing the above to be expressed this way: <lang lisp>(setf (values dividend remainder) (truncate 16 1))</lang>

D

<lang d>import std.stdio, std.typecons;

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

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

}

void main() {

   auto r = addSub(33, 12);
   writefln("33 + 12 = %d\n33 - 12 = %d", r.tupleof);

}</lang>

Output:
33 + 12 = 45
33 - 12 = 21

Déjà Vu

<lang dejavu>function-returning-multiple-values:

    10 20

print print function-returning-multiple-values </lang>

Output:
10
20

Delphi/Pascal

Delphi functions return a single value, but var parameters of a function or procedure can be modified and act as return values. <lang Delphi>program ReturnMultipleValues;

{$APPTYPE CONSOLE}

procedure GetTwoValues(var aParam1, aParam2: Integer); begin

 aParam1 := 100;
 aParam2 := 200;

end;

var

 x, y: Integer;

begin

 GetTwoValues(x, y);
 Writeln(x);
 Writeln(y);

end.</lang>

ECL

<lang>MyFunc(INTEGER i1,INTEGER i2) := FUNCTION

 RetMod := MODULE
   EXPORT INTEGER Add  := i1 + i2;
   EXPORT INTEGER Prod := i1 * i2;
 END;
 RETURN RetMod;

END;

//Reference each return value separately: MyFunc(3,4).Add; MyFunc(3,4).Prod; </lang>

Erlang

<lang erlang>% Implemented by Arjun Sunel -module(return_multi). -export([main/0]).

main() -> K=multiply(3,4), C =lists:nth(1,K), D = lists:nth(2,K), E = lists:nth(3,K), io:format("~p~n",[C]), io:format("~p~n",[D]), io:format("~p~n",[E]).

multiply(A,B) -> case {A,B} of {A, B} ->[A*B, A+B, A-B] end. </lang>

Output:
12
7
-1
ok

Euphoria

Any Euphoria object can be returned. A sequence of objects can be returned, made from multiple data types as in this example. <lang euphoria>include std\console.e --only for any_key, to help make running this program easy on windows GUI

integer aWholeNumber = 1 atom aFloat = 1.999999 sequence aSequence = {3, 4} sequence result = {} --empty initialized sequence

function addmultret(integer first, atom second, sequence third)--takes three kinds of input, adds them all into one element of the..

   return (first + second + third[1]) + third[2] & (first * second * third[1]) * third[2] --..output sequence and multiplies them into..

end function --..the second element

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

any_key()</lang>Output:

{9.999999,23.999988}
Press Any Key to continue...

F#

A function always returns exactly one value. To return multiple results, they are typically packed into a tuple: <lang fsharp>let addSub x y = x + y, x - y

let sum, diff = addSub 33 12 printfn "33 + 12 = %d" sum printfn "33 - 12 = %d" diff</lang>

Output parameters from .NET APIs are automatically converted to tuples by the compiler. It is also possible to use output parameters explicitely with the byref keyword, but this is rarely necessary.

Factor

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. <lang factor>USING: io kernel math prettyprint ; IN: script

*/ ( x y -- x*y x/y )
   [ * ] [ / ] 2bi ;

15 3 */

[ "15 * 3 = " write . ] [ "15 / 3 = " write . ] bi*</lang> 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.

FALSE

<lang false>[\$@$@*@@/]f: { in: a b, out: a*b a/b } 6 2f;! .` ,. { 3 12 }</lang>

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.). <lang forth>: muldiv ( a b -- a*b a/b )

 2dup / >r * r> ;</lang>

Fortran

Translation of: Haskell

<lang Fortran>module multiple_values implicit none type res

 integer :: p, m

end type

contains

function addsub(x,y) result(r)

 integer :: x, y
 type(res) :: r 
 r%p = x+y
 r%m = x-y

end function end module

program main

 use multiple_values 
 print *, addsub(33, 22)

end program </lang>

Go

Functions can return multiple values in Go: <lang go>func addsub(x, y int) (int, int) {

 return x + y, x - y

}</lang> Or equivalently using named return style: <lang go>func addsub(x, y int) (sum, difference int) {

 sum = x + y
 difference = x - y
 return

}</lang> When a function returns multiple values, you must assign to a comma-separated list of targets: <lang go>sum, difference := addsub(33, 12) fmt.Printf("33 + 12 = %d\n", sum) fmt.Printf("33 - 12 = %d\n", difference)</lang>

Groovy

In Groovy functions return one value. One way to return multiple ones is to use anonymous maps as a sort of tuple. <lang groovy>def addSub(x,y) {

[
 sum: x+y,
 difference: x-y
]

}</lang> Result: <lang groovy>addSub(10,12)

["sum":22, "difference":-2]</lang>

Harbour

Every function returns one value. The conventional way to return multiple values is to bundle them into an array. <lang harbour>Function Addsub( x, y ) Return { x+y, x-y }</lang>

Haskell

Every function returns one value. The conventional way to return multiple values is to return a tuple. <lang haskell>addsub x y =

 (x + y, x - y)</lang>

You can use pattern matching to extract the components: <lang haskell>main = do

 let sum, difference = addsub 33 12
 putStrLn $ "33 + 12 = " ++ show sum
 putStrLn $ "33 - 12 = " ++ show difference</lang>

Icon and 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: <lang Icon>procedure retList() # returns as ordered list return [1,2,3] end

procedure retSet() # returns as un-ordered list insert(S := set(),3,1,2) return S end

procedure retLazy() # return as a generator suspend 1|2|3 end

procedure retTable() # return as a table T := table() T["A"] := 1 T["B"] := 2 T["C"] := 3 return T end

record retdata(a,b,c)

procedure retRecord() # return as a record, least general method return retdata(1,2,3) end</lang>

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 sort of like asking how to return only one value in another language. <lang j> 1 2+3 4 4 6</lang>

Java

Translation of: NetRexx

<lang Java>import java.util.List; import java.util.ArrayList; import java.util.Map; import java.util.HashMap;

// ============================================================================= public class RReturnMultipleVals {

 public static final String K_lipsum = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.";
 public static final Long   K_1024   = 1024L;
 public static final String L        = "L";
 public static final String R        = "R";
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 public static void main(String[] args) throws NumberFormatException{
   Long nv_;
   String sv_;
   switch (args.length) {
     case 0:
       nv_ = K_1024;
       sv_ = K_lipsum;
       break;
     case 1:
       nv_ = Long.parseLong(args[0]);
       sv_ = K_lipsum;
       break;
     case 2:
       nv_ = Long.parseLong(args[0]);
       sv_ = args[1];
       break;
     default:
       nv_ = Long.parseLong(args[0]);
       sv_ = args[1];
       for (int ix = 2; ix < args.length; ++ix) {
         sv_ = sv_ + " " + args[ix];
       }
       break;
   }
   RReturnMultipleVals lcl = new RReturnMultipleVals();
   Pair<Long, String> rvp = lcl.getPairFromPair(nv_, sv_); // values returned in a bespoke object
   System.out.println("Results extracted from a composite object:");
   System.out.printf("%s, %s%n%n", rvp.getLeftVal(), rvp.getRightVal());
   List<Object> rvl = lcl.getPairFromList(nv_, sv_); // values returned in a Java Collection object
   System.out.println("Results extracted from a Java Colections \"List\" object:");
   System.out.printf("%s, %s%n%n", rvl.get(0), rvl.get(1));
   Map<String, Object> rvm = lcl.getPairFromMap(nv_, sv_); // values returned in a Java Collection object
   System.out.println("Results extracted from a Java Colections \"Map\" object:");
   System.out.printf("%s, %s%n%n", rvm.get(L), rvm.get(R));
 }
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // Return a bespoke object.
 // Permits any number and type of value to be returned
 public <T, U> Pair<T, U> getPairFromPair(T vl_, U vr_) {
   return new Pair<T, U>(vl_, vr_);
 }
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // Exploit Java Collections classes to assemble a collection of results.
 // This example uses java.util.List
 public List<Object> getPairFromList(Object nv_, Object sv_) {
   List<Object> rset = new ArrayList<Object>();
   rset.add(nv_);
   rset.add(sv_);
   return rset;
 }
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // Exploit Java Collections classes to assemble a collection of results.
 // This example uses java.util.Map
 public Map<String, Object> getPairFromMap(Object nv_, Object sv_) {
   Map<String, Object> rset = new HashMap<String, Object>();
   rset.put(L, nv_);
   rset.put(R, sv_);
   return rset;
 }
 // ===========================================================================
 private static class Pair<L, R> {
   private L leftVal;
   private R rightVal;
   public Pair(L nv_, R sv_) {
     setLeftVal(nv_);
     setRightVal(sv_);
   }
   public void setLeftVal(L nv_) {
     leftVal = nv_;
   }
   public L getLeftVal() {
     return leftVal;
   }
   public void setRightVal(R sv_) {
     rightVal = sv_;
   }
   public R getRightVal() {
     return rightVal;
   }
 }

}</lang>

Julia

<lang julia>function addsub(x, y)

 return x + y, x - y

end</lang>

julia> addsub(10,4)
(14,6)


Lasso

<lang Lasso>define multi_value() => { return (:'hello word',date) } // shows that single method call will return multiple values // the two values returned are assigned in order to the vars x and y local(x,y) = multi_value

'x: '+#x '\ry: '+#y</lang>

Output:
x: hello word
y: 2013-11-06 01:03:47

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. <lang lb>data$ ="5 6 7 22 9 3 4 8 7 6 3 -5 2 1 8 9"

a$ =minMax$( data$) print " Minimum was "; word$( a$, 1, " "); " & maximum was "; word$( a$, 2, " ")

end

function minMax$( i$) min = 1E6 max =-1E6 i =1 do

   t$    =word$( i$, i, " ")
   if t$ ="" then exit do
   v     =val( t$)
   min   =min( min, v)
   max   =max( max, v)
   i =i +1

loop until 0 minMax$ =str$( min) +" " +str$( max) end function</lang>

 Minimum was -5 & maximum was 22

Lua

<lang lua>function addsub( a, b )

   return a+b, a-b

end

s, d = addsub( 7, 5 ) print( s, d )</lang>

Maple

<lang Maple>> sumprod := ( a, b ) -> (a + b, a * b): > sumprod( x, y );

                              x + y, x y

> sumprod( 2, 3 );

                                 5, 6</lang>

The parentheses are needed here only because of the use of arrow ("->") notation to define the procedure. One could do, instead: <lang Maple>sumprod := proc( a, b ) a + b, a * b end:</lang>

Mathematica

<lang Mathematica>addsub [x_,y_]:= List [x+y,x-y] addsub[4,2]</lang>

Output

{6,2}

MATLAB / Octave

<lang Matlab> function [a,b,c]=foo(d)

   a = 1-d; 
   b = 2+d; 
   c = a+b;
 end;  
 [x,y,z] = foo(5) </lang>

Output: <lang Matlab> > [x,y,z] = foo(5)

 x = -4
 y =  7
 z =  3 </lang>

Maxima

<lang maxima>f(a, b) := [a * b, a + b]$

[u, v]: f(5, 6); [30, 11]</lang>

Mercury

Mercury is a logic language. Its unification semantics permit any number of output parameters (the closest equivalent to return values). The sample code provided here centres on the addsub/4 predicate. The mode statement identifies the first two parameters as input parameters and the last two as output parameters, thus, in effect, returning two results. In this case the first output parameter returns the sum of the two inputs and the second output returns the difference of the two inputs.

addsub.m

<lang mercury>

- module addsub.
- interface.
- import_module io.
- pred main(io::di, io::uo) is det.
- implementation.
- import_module int, list, string.

main(!IO) :-

   command_line_arguments(Args, !IO),
   filter_map(to_int, Args, CleanArgs),
   (length(CleanArgs, 2) ->
       X = det_index1(CleanArgs,1),
       Y = det_index1(CleanArgs,2),
       addsub(X, Y, S, D),
       format("%d + %d = %d\n%d - %d = %d\n", 
              [i(X), i(Y), i(S), i(X), i(Y), i(D)], !IO)
   ;
       write_string("Please pass two integers on the command line.\n", !IO)
   ).
- pred addsub(int::in, int::in, int::out, int::out) is det.

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

   S = X + Y,
   D = X - Y.

</lang>

Use and output

$ mmc addsub.m -E && ./addsub 100 999   
100 + 999 = 1099
100 - 999 = -899

Nemerle

To return multiple values in Nemerle, package them into a tuple. <lang Nemerle>using System; using System.Console; using Nemerle.Assertions;

module MultReturn {

   MinMax[T] (ls : list[T]) : T * T
     where T : IComparable
     requires ls.Length > 0 otherwise throw ArgumentException("An empty list has no extreme values.")
   {
       def greaterOf(a, b) { if (a.CompareTo(b) > 0) a else b }
       def lesserOf(a, b)  { if (a.CompareTo(b) < 0) a else b }
       
       (ls.FoldLeft(ls.Head, lesserOf), ls.FoldLeft(ls.Head, greaterOf)) // packing tuple
   }
   
   Main() : void
   {
       def nums = [1, 34, 12, -5, 4, 0];
       def (min, max) = MinMax(nums);                                   // unpacking tuple
       WriteLine($"Min of nums = $min; max of nums = $max");
   }

}</lang>

NetRexx

While a NetRexx method can only return a single "thing" to it's caller that "thing" can be an object which may contain a great deal of information. Typical return objects can be composite objects, Java Collection Class objects, NetRexx indexed strings etc.

Another common idiom inherited from REXX is the ability to collect the return data into a simple NetRexx string. Caller can then use the PARSE instruction to deconstruct the return value and assign the parts to separate variables. <lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols nobinary

-- ============================================================================= class RReturnMultipleVals public

 properties constant
   L = 'L'
   R = 'R'
   K_lipsum = 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.'
   K_1024 = 1024
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 method RReturnMultipleVals() public
   return
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 method main(args = String[]) public static
   arg = Rexx(args)
   parse arg nv_ sv_ .
   if \nv_.datatype('n') then nv_ = K_1024
   if sv_ =  then sv_ = K_lipsum
   lcl = RReturnMultipleVals()
   rvr = lcl.getPair(nv_, sv_) -- multiple values returned as a string.  Use PARSE to extract values
   parse rvr val1 val2
   say 'Results extracted from a NetRexx string:'
   say val1',' val2
   say
   rvr = lcl.getPairFromRexx(nv_, sv_) -- values returned in a NetRexx indexed string
   say 'Results extracted from a NetRexx "indexed string":'
   say rvr[L]',' rvr[R]
   say
   rvp = lcl.getPairFromPair(nv_, sv_) -- values returned in a bespoke object
   say 'Results extracted from a composite object:'
   say rvp.getLeftVal',' rvp.getRightVal
   say
   rvl = lcl.getPairFromList(nv_, sv_) -- values returned in a Java Collection "List" object
   say 'Results extracted from a Java Colections "List" object:'
   say rvl.get(0)',' rvl.get(1)
   say
   rvm = lcl.getPairFromMap(nv_, sv_) -- values returned in a Java Collection "Map" object
   say 'Results extracted from a Java Colections "Map" object:'
   say rvm.get(L)',' rvm.get(R)
   say
   return
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- returns the values in a NetRexx string.
 --  Caller can the power of PARSE to extract the results
 method getPair(nv_, sv_) public returns Rexx
   return nv_ sv_
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- Return the values as members of a NetRexx indexed string
 method getPairFromRexx(nv_, sv_) public returns Rexx
   rval = 
   rval[L] = nv_
   rval[R] = sv_
   return rval
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- Return a bespoke object.
 -- Permits any number and type of value to be returned
 method getPairFromPair(nv_, sv_) public returns RReturnMultipleVals.Pair
   rset = RReturnMultipleVals.Pair(nv_, sv_)
   return rset
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- Exploit Java Collections classes to assemble a collection of results.
 -- This example uses java.util.List
 method getPairFromList(nv_, sv_) public returns java.util.List
   rset = ArrayList()
   rset.add(nv_)
   rset.add(sv_)
   return rset
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- This example uses java.util.Map
 method getPairFromMap(nv_, sv_) public returns java.util.Map
   rset = HashMap()
   rset.put(L, nv_)
   rset.put(R, sv_)
   return rset

-- ============================================================================= class RReturnMultipleVals.Pair dependent

 properties indirect
   leftVal
   rightVal
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 method Pair(nv_ = parent.K_1024, sv_ = parent.K_lipsum) public
   setLeftVal(nv_)
   setRightVal(sv_)
   return

</lang>

OCaml

Every function returns one value. The conventional way to return multiple values is to return a tuple. <lang ocaml>let addsub x y =

 x + y, x - y</lang>

(Note that parentheses are not necessary for a tuple literal in OCaml.)

You can use pattern matching to extract the components: <lang ocaml>let sum, difference = addsub 33 12 in

 Printf.printf "33 + 12 = %d\n" sum;
 Printf.printf "33 - 12 = %d\n" difference</lang>

Space safety of tuples

The OCaml programmer should be aware that when multiple values are returned with a tuple, the finalisation does not handle each values independently, but handles the tuple as a whole. So all the values are only finalised when all the values are not reachable anymore.

There is also an explanation of this behaviour in the module Space_safe_tuple of the Jane Street's core library. <lang ocaml>let pair a b =

 let ra = Array.create 1 a
 and rb = Array.create 1 b in
 let f r = Printf.printf "> finalised: %d\n%!" r.(0) in
 Gc.finalise f ra;
 Gc.finalise f rb;
 (ra, rb)

let () =

 let a, b = pair 1 2 in
 let c, d = pair 3 4 in
 Gc.full_major ();  (* garbage collection *)
 Printf.printf "Used: %d\n%!" a.(0)</lang>

Here we see that b is not finalised even if it is not used after the garbage collection:

$ ocamlopt -w y -o pair.opt pair.ml
$ ./pair.opt 
> finalised: 4
> finalised: 3
Used: 1

The workaround is to explicitly access to each value with functions like fst and snd that return only one element of the tuple: <lang ocaml>val fst : 'a * 'b -> 'a val snd : 'a * 'b -> 'b</lang> <lang ocaml>let pair a b =

 let ra = Array.create 1 a
 and rb = Array.create 1 b in
 let f r = Printf.printf "> finalised: %d\n%!" r.(0) in
 Gc.finalise f ra;
 Gc.finalise f rb;
 (ra, rb)

let () =

 let ab = pair 1 2 in
 let a = fst ab
 and b = snd ab in
 let c, d = pair 3 4 in
 Gc.full_major ();  (* garbage collection *)
 Printf.printf "Used: %d\n%!" a.(0)</lang>

Now we see that b is finalised:

$ ocamlopt -w y -o pair2.opt pair2.ml
$ ./pair2.opt 
> finalised: 4
> finalised: 3
> finalised: 2
Used: 1

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: <lang ooRexx> r = addsub(3, 4) say r[1] r[2]

routine addsub
 use arg x, y
 return .array~of(x + y, x - y)

</lang> Output:

7 -1


OxygenBasic

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

<lang oxygenbasic>

'============ class vector4 '============

float w,x,y,z

method values(float fw,fx,fy,fz) this <= fw, fx, fy, fz end method

method values(vector4 *v) this <= v.w, v.x, v.y, v.z end method

method values() as vector4 return this end method

method ScaledValues(float fw,fx,fy,fz) as vector4 static vector4 v v <= w*fw, x*fx, y*fy, z*fz return v end method

method ShowValues() as string string cm="," return w cm x cm y cm z end method

end class

vector4 aa,bb

bb.values = 1,2,3,4

aa.values = bb.Values()

print aa.ShowValues() 'result 1,2,3,4

aa.values = bb.ScaledValues(100,100,-100,100)

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

</lang>

PARI/GP

The usual way to return multiple values is to put them in a vector: <lang parigp>foo(x)={

 [x^2, x^3]

};</lang>

Perl

Functions may return lists of values: <lang perl>sub foo {

   my ($a, $b) = @_;
   return $a + $b, $a * $b;

}</lang>

Perl 6

Each function officially returns one value, but by returning a Parcel you can transparently return a lazy list of arbitrary size. <lang perl6>sub foo($a,$b) {

   $a + $b, $a * $b, $b xx $a

}

say foo 3, 7;</lang>

Output:
10 21 7 7 7

PHP

Every function returns one value. The conventional way to return multiple values is to bundle them into an array. <lang php>function addsub($x, $y) {

 return array($x + $y, $x - $y);

}</lang> You can use the list() construct to assign to multiple variables: <lang php>list($sum, $difference) = addsub(33, 12); echo "33 + 12 = $sum\n"; echo "33 - 12 = $difference\n";</lang>

PicoLisp

A PicoLisp function returns a single value. For multiple return values, a cons pair or a list may be used. <lang PicoLisp>(de addsub (X Y)

  (list (+ X Y) (- X Y)) )</lang>

Test: <lang PicoLisp>: (addsub 4 2) -> (6 2)

(addsub 3 1)

-> (4 2)

(+ (car (addsub 4 2)) (car (addsub 3 1)))

-> 10

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

-> 14</lang>

Pike

Multiple values are returned through an array. An array can be assigned to separate variables. <lang Pike>array(int) addsub(int x, int y) {

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

}

[int z, int w] = addsub(5,4);</lang>

PL/I

Example 1 illustrates a function that returns an array: <lang PL/I> define structure 1 h,

                     2 a (10) float;
  declare i fixed binary;

sub: procedure (a, b) returns (type(h));

  declare (a, b) float;
  declare p type (h);
  do i = 1 to 10;
     p.a(i) = i;
  end;
  return (p);

end sub;</lang> Example 2 illustrates a function that returns a general data structure: <lang PL/I> define structure 1 customer,

                     2 name,
                       3 surname character (20),
                       3 given_name character (10),
                     2 address,
                       3 street character (20),
                       3 suburb character (20),
                       3 zip fixed decimal (7);

sub2: procedure() returns (type(customer));

  declare c type (customer);
  get edit (c.surname, c.given_name) (L);
  get edit (c.street, c.suburb, c.zip) (L);
  return (c);

end sub2;</lang> Example 3 illustrates the return of two values as a complex value: <lang PL/I>comp: procedure(a, b) returns (complex);

  declare (a, b) float;
  return (complex(a, b) );

end comp;</lang>

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). <lang purebasic>;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.

Procedure example_1(x, y, Array r(1)) ;array r() will contain the return values

 Dim r(2) ;clear and resize the array
 r(0) = x + y  ;return these values in the array
 r(1) = x - y
 r(2) = x * y 

EndProcedure

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

Procedure example_2(x, y)

 Protected *result.POINT = AllocateMemory(SizeOf(POINT))
 *result\x = x
 *result\y = y
 ProcedureReturn *result ;*result points to a 'POINT' structure containing x and y

EndProcedure

If OpenConsole()

 Dim a(5)
 example_1(6, 5, a()) ;a() now contains {11, 1, 30}
 PrintN("Array returned with {" + Str(a(0)) + ", " + Str(a(1)) + ", " + Str(a(2)) + "}")
 
 Define *aPoint.POINT
 *aPoint = example_2(6, 5) ;*aPoint references structured memory containing {6, 5}
 
 PrintN("structured memory holds: (" + Str(*aPoint\x) + ", " + Str(*aPoint\y) + ")")
  FreeMemory(*aPoint) ;freememory
 
 Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
 CloseConsole()

EndIf</lang>

Python

Every function returns one value. The conventional way to return multiple values is to bundle them into a tuple. <lang python>def addsub(x, y):

 return x + y, x - y</lang>

(Note that parentheses are not necessary for a tuple literal in Python.)

You can assign to a comma-separated list of targets: <lang python>sum, difference = addsub(33, 12) print "33 + 12 = %s" % sum print "33 - 12 = %s" % difference</lang> There is no discernable 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.

R

The conventional way to return multiple values is to bundle them into a list. <lang R>addsub <- function(x, y) list(add=(x + y), sub=(x - y))</lang>

Racket

Racket has a defined function "values" that returns multiple values using continuations, a way it can be implemented is shown in "my-values" <lang Racket>#lang racket (values 4 5)

(define (my-values . return-list)

 (call/cc
  (lambda (return)
    (apply return return-list))))</lang>

Raven

<lang Raven>define multiReturn use $v

  $v each 

3 multiReturn</lang>

Output:
2
1
0

Retro

Functions take and return values via a stack. This makes returning multiple values easy. <lang Retro>: addSubtract ( xy-nm )

 2over - [ + ] dip ;</lang>

REXX

Strictly speaking, REXX only returns one value (or no values), but the value (a string) can
comprise of multiple "values" or substrings.
If the multiple values are seperated by blanks [or some other unique character(s) such as
a comma, semicolon, blackslash, ...], it's a very simple matter to parse the multiple-value
string into the desired substrings (or values, if you will) with the handy-dandy PARSE statement. <lang REXX>/*REXX program shows examples of multiple RETURN values from a function.*/ numeric digits 70 /*default is: NUMERIC DIGITS 9 */ arg a b /*get 2 numbers from comand line.*/ say ' a =' a /*display the first number. */ say ' b =' b /* " " second " */ say copies('=',50) /*display a separator line. */

z=giveMeBackStuff(a,b) /*call function: giveMeBackStuff */

parse var z sum dif mod div idiv prod pow /*get the returned values,*/

                          prod=word(z,6)     /*obtain an alternate way.*/

say ' + =' sum say ' - =' dif say '// =' mod say ' / =' div say ' % =' idiv say ' * =' prod say '** =' pow exit /*stick a fork in it, we're done.*/ /*──────────────────────────────────giveMeBackStuff subroutine──────────*/ giveMeBackStuff: procedure; parse arg x,y

     addition = x+y
     subtract = x-y
     modulus  = x//y
     divide   = x/y
     intDiv   = x%y
     multiply = x*y
     power    = x**y

return addition subtract modulus divide intDiv multiply power /*──────────────────────────────────giveMeBackStuff2 subroutine─────────*/ giveMeBackStuff2: procedure; parse arg x,y return x+y x-y x//y x/y x%y x*y x**y /*same as version above.*/</lang> output when the following is used for input: 82 20

 a = 82
 b = 20
==================================================
 + = 102
 - = 62
// = 2
 / = 4.1
 % = 4
 * = 1640
** = 188919613181312032574569023867244773376

Ruby

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

Use an array literal: <lang ruby>def addsub(x, y)

 [x + y, x - y]

end</lang> Or use return with 2 or more values: <lang ruby>def addsub(x, y)

 return x + y, x - y

end</lang>

(With at least 2 values, return makes a new Array. With 1 value, return passes the value, without making any Array. With 0 values, return passes nil.)

Assignment can split the Array into separate variables. <lang ruby>sum, difference = addsub(33, 12) puts "33 + 12 = #{sum}" puts "33 - 12 = #{difference}"</lang>

Run BASIC

Courtesy http://dkokenge.com/rbp
Gets the UTC time from the web <lang runbasic>a$ = timeInfo$() print " UTC:";word$(a$,1,"|") print "Date:";word$(a$,2,"|") print "Time:";word$(a$,3,"|") wait function timeInfo$() utc$ = word$(word$(httpget$("http://tycho.usno.navy.mil/cgi-bin/timer.pl"),1,"UTC"),2,"
") ' Universal time d$ = date$() t$ = time$() timeInfo$ = utc$;"|";d$;"|";t$ end function</lang>

Scala

Every function returns one value. The conventional way to return multiple values is to return a tuple. <lang scala>def addsub(x: Int, y: Int) = (x + y, x - y)</lang> You can use pattern matching to extract the components: <lang scala>val (sum, difference) = addsub(33, 12)</lang> Scala borrows this idea from ML, and generalizes it into extractors.

Scheme

Scheme can return multiple values using the values function, which uses continuations: <lang scheme>(define (addsub x y)

 (values (+ x y) (- x y)))</lang>

You can use the multiple values using the call-with-values function: <lang scheme>(call-with-values

 (lambda () (addsub 33 12))
 (lambda (sum difference)
   (display "33 + 12 = ") (display sum) (newline)
   (display "33 - 12 = ") (display difference) (newline)))</lang>

The syntax is kinda awkward. SRFI 8 introduces a receive construct to make this simpler: <lang scheme>(receive (sum difference) (addsub 33 12)

 ; in this scope you can use sum and difference
 (display "33 + 12 = ") (display sum) (newline)
 (display "33 - 12 = ") (display difference) (newline))</lang>

SRFI 11 introduces a let-values construct to make this simpler: <lang scheme>(let-values (((sum difference) (addsub 33 12)))

 ; in this scope you can use sum and difference
 (display "33 + 12 = ") (display sum) (newline)
 (display "33 - 12 = ") (display difference) (newline))</lang>

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 inout parameters: <lang Seed7>$ include "seed7_05.s7i";

const proc: sumAndDiff (in integer: x, in integer: y, inout integer: sum, inout integer: diff) is func

 begin
   sum := x + y;
   diff := x - y;
end func;

const proc: main is func

 local
   var integer: sum is 0;
   var integer: diff is 0;
 begin
   sumAndDiff(5, 3, sum, diff);
   writeln("Sum: " <& sum);
   writeln("Diff: " <& diff);
 end func;</lang>
Output:
Sum: 8
Diff: 2

Standard ML

Every function returns one value. The conventional way to return multiple values is to return a tuple. <lang sml>fun addsub (x, y) =

 (x + y, x - y)</lang>

You can use pattern matching to extract the components: <lang sml>let

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

in

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

end</lang>

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 return command or the result of the final command in the body in the procedure. (Commands that return “no” value actually return the empty string.) <lang tcl>proc addsub {x y} {

   list [expr {$x+$y}] [expr {$x-$y}]

}</lang> This can be then assigned to a single variable with set or to multiple variables with lassign. <lang tcl>lassign [addsub 33 12] sum difference puts "33 + 12 = $sum, 33 - 12 = $difference"</lang>

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: <lang txr>@(define func (x y z)) @ (bind w "discarded") @ (bind (x y z) ("a" "b" "c")) @(end)</lang> The binding w, if created, is discarded because w is not in the list of formal parameters. However, w can cause the function to fail because there can already exist a variable w with a value which doesn't match "discarded".

Call: <lang txr>@(func t r s)</lang> If t, r and s are unbound variables, they get bound to "a", "b" and "c", 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"): <lang txr>@(func "1" r s)</lang> Successful call binding only one new variable: <lang txr>@(func "a" "b" s)</lang>

UNIX Shell

Shell scripts don't directly support returning values from a function, it can be simulated through some clunky code.

<lang bash>

  1. !/bin/sh

funct1() {

 a=$1
 b=`expr $a + 1`
 echo $a $b

}

values=`funct1 5`

set $values x=$1 y=$2 echo "x=$x" echo "y=$y" </lang>

Output produced:

x=5
y=6

XPL0

<lang XPL0>include c:\cxpl\codes; \intrinsic 'code' declarations

proc Rect2Polar(X,Y,A,D); \Return two polar coordinate values real X,Y,A,D; [A(0):= ATan2(Y,X);

D(0):= Sqrt(X*X+Y*Y);

]; \Rect2Polar

real Ang, Dist; [Rect2Polar(4.0, 3.0, @Ang, @Dist); \("@" is a new feature similar to 'addr') RlOut(0, Ang); RlOut(0, Dist); CrLf(0); ]</lang>

Output (angle is in radians):

    0.64350    5.00000