Return multiple values

Task

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

11l

Translation of: Python

<lang 11l>F addsub(x, y)

  R (x + y, x - y)

V (summ, difference) = addsub(33, 12) print(‘33 + 12 = ’summ) print(‘33 - 12 = ’difference)</lang>

Output:

33 + 12 = 45
33 - 12 = 21

6502 Assembly

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. JSR UnpackNibbles. <lang 6502asm>UnpackNibbles:

Takes accumulator as input.
Separates a two-digit hex number into its component "nibbles." Left nibble in X, right nibble in Y.

pha ;backup the input. and #$0F ;chop off the left nibble. What remains is our Y. tay pla ;restore input and #$F0 ;chop off the right nibble. What remains is our X, but it needs to be bit shifted into the right nibble. lsr lsr lsr lsr tax ;store in X rts</lang>

68000 Assembly

Translation of: ARM Assembly

A function's "return value" is nothing more than the register state upon exit. However, to ensure compatibility between software, there are general calling conventions that compiler-written code will follow that standardizes which registers are used to return values from a function.

This code returns the sum and difference of two integers, which will be passed in via registers D2 and D3. D2+D3 is returned in D0, D2-D3 is returned in D1.

8086 Assembly

Translation of: ARM Assembly

A function's "return value" is nothing more than the register state upon exit. However, to ensure compatibility between software, there are general calling conventions that compiler-written code will follow that standardizes which registers are used to return values from a function.

This function takes two 16-bit numbers in CX and DX, and outputs their sum to AX and their difference to BX.

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>

Action!

The user must type in the monitor the following command after compilation and before running the program!

SET EndProg=*

Library: Action! Tool Kit

<lang Action!>CARD EndProg ;required for ALLOCATE.ACT

INCLUDE "D2:ALLOCATE.ACT" ;from the Action! Tool Kit. You must type 'SET EndProg=*' from the monitor after compiling, but before running this program!

DEFINE PTR="CARD" DEFINE RECORD_SIZE="6" TYPE Record=[CARD min,max,sum]

PROC ArgumentsAsPointers(CARD ARRAY a BYTE n CARD POINTER min,max,sum)

 BYTE i

 min^=65535 max^=0 sum^=0
 FOR i=0 TO n-1
 DO
   IF a(i)>max^ THEN
     max^=a(i)
   FI
   IF a(i)<min^ THEN
     min^=a(i)
   FI
   sum^==+a(i)
 OD

RETURN

PROC ArgumentAsRecord(CARD ARRAY a BYTE n Record POINTER res)

 BYTE i

 res.min=65535 res.max=0 res.sum=0
 FOR i=0 TO n-1
 DO
   IF a(i)>res.max THEN
     res.max=a(i)
   FI
   IF a(i)<res.min THEN
     res.min=a(i)
   FI
   res.sum==+a(i)
 OD

RETURN

PTR FUNC ResultAsRecord(CARD ARRAY a BYTE n)

 Record POINTER res
 BYTE i

 res=Alloc(RECORD_SIZE)
 res.min=65535 res.max=0 res.sum=0
 FOR i=0 TO n-1
 DO
   IF a(i)>res.max THEN
     res.max=a(i)
   FI
   IF a(i)<res.min THEN
     res.min=a(i)
   FI
   res.sum==+a(i)
 OD

RETURN (res)

PROC Main()

 CARD ARRAY a=[123 5267 42 654 234 6531 4432]
 CARD minV,maxV,sumV
 Record rec
 Record POINTER p

 Put(125) PutE() ;clear screen 
 AllocInit(0)

 ArgumentsAsPointers(a,7,@minV,@maxV,@sumV)
 PrintE("Return multiple values by passing arguments as pointers:")
 PrintF("min=%U max=%U sum=%U%E%E",minV,maxV,sumV)

 ArgumentAsRecord(a,7,rec)
 PrintE("Return multiple values by passing argument as pointer to a record:")
 PrintF("min=%U max=%U sum=%U%E%E",rec.min,rec.max,rec.sum)

 p=ResultAsRecord(a,7)
 PrintE("Return multiple values by returning a pointer to a record:")
 PrintF("min=%U max=%U sum=%U%E",p.min,p.max,p.sum)

 Free(p,RECORD_SIZE)

RETURN</lang>

Output:

Screenshot from Atari 8-bit computer

Return multiple values by passing arguments as pointers:
min=42 max=6531 sum=17283

Return multiple values by passing argument as pointer to a record:
min=42 max=6531 sum=17283

Return multiple values by returning a pointer to a record:
min=42 max=6531 sum=17283

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

Agena

Agena allows functions to return multiple values.
Tested with Agena 2.9.5 Win32 <lang agena># define a function returning three values mv := proc() is

   return 1, 2, "three"

end ; # mv

scope # test the mv() proc

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

epocs</lang>

ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.6.win32

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. <lang algol68># example mode for returning multiple values from a procedure # MODE PAIR = STRUCT( STRING name, INT value );

procedure returning multiple values via a structure #

PROC get pair = ( INT a )PAIR:

   CASE a
   IN #1#    ( "H",  0 )
   ,  #2#    ( "He", 1 )
   ,  #3#    ( "Li", 3 )
   OUT       ( "?",  a )
   ESAC

main: (

   # use the result as a whole #
   print( ( get pair( 3 ), newline ) );
   # access the components separately #
   print( ( name OF get pair( 1 ), value OF get pair( 2 ), newline ) )

)</lang>

Output:

Li         +3
H         +1

ALGOL W

Algol W procedures can't return arrays but records can be used to return multiple values. <lang algolw>begin

   % example using a record type to return multiple values from a procedure %
   record Element ( string(2) symbol; integer atomicNumber );
   reference(Element) procedure getElement( integer value n ) ;
   begin
       Element( if      n < 1 then   "?<"
                else if n > 3 then   "?>"
                else case n of ( %1% "H"
                               , %2% "He"
                               , %3% "Li"
                               )
              , n
              )
   end getElement ;
   % test the procedure %
   begin
       reference(Element) elementData;
       for n := 0 until 4 do begin
           elementData := getElement(n);
           write( s_w := 0, i_w := 1
                , atomicNumber(elementData)
                , " "
                , symbol(elementData)
                );
       end
   end

end.</lang>

ANSI Standard BASIC

The most straightforward way of returning multiple values is to specify them as parameters. <lang ANSI Standard 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</lang>

ARM Assembly

When programming without any rules governing the way you write functions, a function's "return value" is nothing more than the register state upon exit. However, the AAPCS calling convention dictates that the R0 register is used to store a function's return value. (If the return value is larger than 32 bits, the registers R1-R3 can also be used.) Following this standard is necessary for human-written assembly code to properly interface with code written by a C compiler.

<lang ARM Assembly>sum:

int sum(int a,int b){return a+b;}
takes R0 and R1 as arguments, outputs their sum to R0.

ADD R0,R0,R1 bx lr</lang>

Arturo

<lang rebol>addsub: function [x y]->

   @[x+y x-y]

a: 33 b: 12

result: addsub a b

print [a "+" b "=" result\0] print [a "-" b "=" result\1]</lang>

Output:

33 + 12 = 45 
33 - 12 = 21

ATS

Every function returns one value. The conventional way to return multiple values is to return a tuple. <lang ATS>//

include

"share/atspre_staload.hats" // (* ****** ****** *)

fun addsub (

 x: int, y: int

) : (int, int) = (x+y, x-y)

(* ****** ****** *)

implement main0 () = let

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

in

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

end (* end of [main0] *)</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>

BASIC

BaCon

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

<lang freebasic>' Return multiple values RECORD multi

   LOCAL num
   LOCAL s$[2]

END RECORD

FUNCTION f(n) TYPE multi_type

   LOCAL r = { 0 } TYPE multi_type
   r.num = n
   r.s$[0] = "Hitchhiker's Guide"
   r.s$[1] = "Douglas Adams"
   RETURN r

END FUNCTION

DECLARE rec TYPE multi_type rec = f(42) PRINT rec.num PRINT rec.s$[0] PRINT rec.s$[1]</lang>

Output:

prompt$ ./return-multiple
42
Hitchhiker's Guide
Douglas Adams

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>

IS-BASIC

<lang IS-BASIC>100 NUMERIC SUM,DIFF 110 CALL SUMDIFF(5,3,SUM,DIFF) 120 PRINT "Sum is";SUM:PRINT "Difference is";DIFF 130 END 140 DEF SUMDIFF(A,B,REF C,REF D) 150 LET C=A+B:LET D=A-B 160 END DEF</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 preferred way to return multiple values in C# is to use "out" paremeters on the method. This can be in addition to the value returned by the method. <lang c sharp>using System; using System.Collections.Generic; using System.Linq;

class ReturnMultipleValues {

   static void Main()
   {
       var values = new[] { 4, 51, 1, -3, 3, 6, 8, 26, 2, 4 };
       int max, min;
       MinMaxNum(values, out max, out min);

       Console.WriteLine("Min: {0}\nMax: {1}", min, max);
   }

   static void MinMaxNum(IEnumerable<int> nums, out int max, out int min)
   {
       var sortedNums = nums.OrderBy(num => num).ToArray();
       max = sortedNums.Last();
       min = sortedNums.First();
   }

}</lang>

Output:

Min: -3
Max: 51

C++

Since C++11, the C++-standard-library includes tuples, as well as an easy way to destructure them. <lang cpp>#include <algorithm>

include <array>
include <cstdint>
include <iostream>
include <tuple>

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

  const auto maximum = std::max_element(numbers, numbers + num);
  const auto minimum = std::min_element(numbers, numbers + num);
  return std::make_tuple(*minimum, *maximum) ;

}

int main( ) {

  const auto numbers = std::array<int, 8>Template:17, 88, 9, 33, 4, 987, -10, 2;
  int min{};
  int max{};
  std::tie(min, max) = minmax(numbers.data(), numbers.size());
  std::cout << "The smallest number is " << min << ", the biggest " << max << "!\n" ;

}</lang>

Output:

The smallest number is -10, the biggest 987!

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>

CLU

<lang clu>% Returning multiple values (along with type parameterization) % was actually invented with CLU.

% Do note that the procedure is actually returning multiple % values; it's not returning a tuple and unpacking it. % That doesn't exist in CLU.

% For added CLU-ness, this function is fully general, requiring % only that its arguments support addition and subtraction in any way

add_sub = proc [T,U,V,W: type] (a: T, b: U) returns (V, W)

         signals (overflow)
         where T has add: proctype (T,U) returns (V) signals (overflow),
                     sub: proctype (T,U) returns (W) signals (overflow)
   return (a+b, a-b) resignal overflow

end add_sub

% And actually using it start_up = proc ()

   add_sub_int = add_sub[int,int,int,int] % boring, but does what you'd expect
   po: stream := stream$primary_output()
   
   % returning two values from the function
   sum, diff: int := add_sub_int(33, 12)

   % print out both
   stream$putl(po, "33 + 12 = " || int$unparse(sum))
   stream$putl(po, "33 - 12 = " || int$unparse(diff))

end start_up</lang>

Output:

33 + 12 = 45
33 - 12 = 21

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>

COBOL

COBOL normally passes data BY REFERENCE, which is the default mode, effectively making the arguments modifiable.

User Defined Functions return a single argument, but that argument can be a group item.

Most large scale COBOL programs will attempt to keep from repeating itself, in terms of data layouts, using external copy books and the COBOL COPY statement. This example uses in source REPLACE to avoid copy books.

Works with: GnuCOBOL

      identification division.
      program-id. multiple-values.

      environment division.
      configuration section.
      repository.
          function multiples
          function all intrinsic.

      REPLACE ==:linked-items:== BY ==
      01 a usage binary-long.
      01 b pic x(10).
      01 c usage float-short.
      ==
      ==:record-item:== BY ==
      01 master.
         05 ma usage binary-long.
         05 mb pic x(10).
         05 mc usage float-short.
      ==.

      data division.
      working-storage section.
      :linked-items:

      :record-item:
      
      procedure division.
      sample-main.

      move 41 to a
      move "aaaaabbbbb" to b
      move function e to c

      display "Original: " a ", " b ", " c
      call "subprogram" using a b c
      display "Modified: " a ", " b ", " c
      
      move multiples() to master
      display "Multiple: " ma ", " mb ", " mc

      goback.
      end program multiple-values.

     *> subprogram
      identification division.
      program-id. subprogram.

      data division.
      linkage section.
      :linked-items:

      procedure division using a b c.
      add 1 to a
      inspect b converting "a" to "b"
      divide 2 into c
      goback.
      end program subprogram.

     *> multiples function
      identification division.
      function-id. multiples.

      data division.
      linkage section.
      :record-item:

      procedure division returning master.
      move 84 to ma
      move "multiple" to mb
      move function pi to mc
      goback.
      end function multiples.

</lang>

Output:

prompt$ cobc -xj multiple-values.cob
Original: +0000000041, aaaaabbbbb, 2.7182817
Modified: +0000000042, bbbbbbbbbb, 1.3591409
Multiple: +0000000084, multiple  , 3.1415927

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>

Cowgol

<lang cowgol>include "cowgol.coh";

In Cowgol, subroutines can simply define multiple output parameters.

sub MinMax(arr: [uint8], len: intptr): (min: uint8, max: uint8) is

   min := 255;
   max := 0;
   while len > 0 loop
       len := len - 1;
       var cur := [arr];
       if min > cur then min := cur; end if;
       if max < cur then max := cur; end if; 
       arr := @next arr;
   end loop;
   
   # Values are also returned automatically.

end sub;

Example of usage:

var nums: uint8[] := {23, 65, 33, 12, 95, 5, 32, 91, 135, 25, 8}; var least: uint8; var most: uint8;

Accept two output parameters from a function

(least, most) := MinMax(&nums[0], @sizeof nums);

print("Min: "); print_i8(least); print_nl(); print("Max: "); print_i8(most); print_nl();</lang>

Output:

Min: 5
Max: 135

D

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

mixin template ret(string z) {

   mixin({
       string res;

       auto r = z.split(" = ");
       auto m = r[0].split(", ");
       auto s = m.join("_");

       res ~= "auto " ~ s ~ " = " ~ r[1] ~ ";";
       foreach(i, n; m){
           res ~= "auto " ~ n ~ " = " ~ s ~ "[" ~ i.to!string ~ "];\n";
       }
       return res;
   }());

}

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

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

}

void main() {

   mixin ret!q{ a, b = addSub(33, 12) };

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

}</lang>

Output:

33 + 12 = 45
33 - 12 = 21

Dc

Define a divmod macro ~ which takes a b on the stack and returns a/b a%b. <lang dc>[ S1 S2 l2 l1 / L2 L1 % ] s~ 1337 42 l~ x f</lang>

Output:

35
31

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>

Dyalect

A typical way to return multiple values in Dyalect is to use tuples:

<lang Dyalect>func divRem(x, y) {

   (x / y, x % y)

}</lang>

Déjà Vu

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

    10 20

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

Output:

10
20

EchoLisp

One can return the result of the values function, or a list. <lang scheme> (define (plus-minus x y)

   (values (+ x y) (- x y)))

(plus-minus 3 4)

   → 7
    -1

(define (plus-minus x y)

   (list (+ x y) (- x y)))

(plus-minus 3 4)

   → (7 -1)

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

Eiffel

Every function returns one value. Multiple values can be returned in a tuple. <lang Eiffel>some_feature: TUPLE do Result := [1, 'j', "r"] end</lang> Greater control over the type of return values can also be enforced by explicitly declaring the type of the generic parameters. <lang Eiffel>some_feature: TUPLE[INTEGER_32, CHARACTER_8, STRING_8] do --Result := [ ] -- compile error --Result := [1, "r", 'j'] -- also compile error Result := [1, 'j', "r"] -- okay Result := [1, 'j', "r", 1.23] -- also okay end</lang>

Elena

ELENA 5.0 : <lang elena>import system'routines; import extensions;

extension op {

   MinMax(ref int minVal, ref int maxVal)
   {
       var ordered := self.ascendant();

       minVal := ordered.FirstMember;
       maxVal := ordered.LastMember
   }

}

public program() {

   var values := new int[]{4, 51, 1, -3, 3, 6, 8, 26, 2, 4};

   values.MinMax(ref int min, ref int max);

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

}</lang>

Output:

Min: -3 Max: 51

Elixir

Elixir returns in the tuple form when returning more than one value. <lang elixir>defmodule RC do

 def addsub(a, b) do
   {a+b, a-b}
 end

end

{add, sub} = RC.addsub(7, 4) IO.puts "Add: #{add},\tSub: #{sub}"</lang>

Output:

Add: 11,        Sub: 3

Erlang

<lang erlang>% Put this code in return_multi.erl and run it as "escript return_multi.erl"

-module(return_multi).

main(_) ->

       {C, D, E} = multiply(3, 4),
       io:format("~p ~p ~p~n", [C, D, E]).

multiply(A, B) ->

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

</lang>

Output:

12 7 -1

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. <lang ERRE> PROGRAM RETURN_VALUES

PROCEDURE SUM_DIFF(A,B->C,D)

  C=A+B
  D=A-B

END PROCEDURE

BEGIN

  SUM_DIFF(5,3->SUM,DIFF)
  PRINT("Sum is";SUM)
  PRINT("Difference is";DIFF)

END PROGRAM </lang>

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

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>

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

' One way to return multiple values is to use ByRef parameters for the additional one(s) Function tryOpenFile (fileName As String, ByRef fileNumber As Integer) As Boolean

  Dim result As Integer 
  fileNumber = FreeFile
  result = Open(fileName For Input As # fileNumber)
  If result <> 0 Then
    fileNumber = 0
    Return False
  Else
    Return True
  End If

End Function

Dim fn As Integer Var b = tryOpenFile("xxx.zyz", fn) this file doesn't exist Print b, fn b = tryOpenFile("input.txt", fn) this file does exist Print b, fn Close # fn

' Another way is to use a user defined type

Type FileOpenInfo

 opened As Boolean
 fn As Integer

End Type

Function tryOpenFile2(fileName As String) As FileOpenInfo

  Dim foi As FileOpenInfo 
  foi.fn = FreeFile
  Dim result As Integer
  result = Open(fileName For Input As # foi.fn)   
  If  result <> 0 Then
    foi.fn = 0
    foi.opened = False
  Else
    foi.Opened = True
  End If
  Return foi

End Function

Print Var foi = tryOpenFile2("xxx.zyz") Print foi.opened, foi.fn foi = tryOpenFile2("input.txt") Print foi.opened, foi.fn Close # foi.fn

Print Print "Press any key to quit" Sleep</lang>

Output:

false          0
true           1

false          0
true           1

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. <lang frink> divMod[a, b] := [a div b, a mod b]

[num, remainder] = divMod[10, 3] </lang>

FunL

Translation of: Scala

<lang funl>def addsub( x, y ) = (x + y, x - y)

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

println( sum, difference, addsub(33, 12) )</lang>

Output:

45, 21, (45, 21)

FutureBasic

FutureBasic offers several ways to return multiple values from a function: by passing pointers to multiple values in and out of functions; global records (structures); global containers (imagine a global bit bucket that can hold up to 2GBs of data); and global arrays of either the standard kind, or of FB's dynamic arrays.

Here is an example of returning multiple values using pointers: <lang futurebasic> include "ConsoleWindow"

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

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

dim as Str255 outStr dim as long outCount

fn ReturnMultipleValues( "Hello, World!", @outStr, @outCount ) print outStr; ". The combined strings have"; outCount; " letters in them." </lang>

Output:

Here is your original string: Hello, World!. The combined strings have 43 letters in them.

Another way to pass multiple values from a function is with records (AKA structures): <lang> include "ConsoleWindow"

// Elements in global array _maxDim = 3

begin record Addresses dim as Str63 name dim as Str15 phone dim as long zip end record

begin globals dim as Addresses gAddressData(_maxDim) 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

// Pass address of global array to fill it fn FillRecord( gAddressData(0) )

dim as short i

for i = 0 to 2

  print gAddressData.name(i); ", ";
  print gAddressData.phone(i); ", Zip:";
  print gAddressData.zip(i)

next </lang>

Output:

John Doe, 555-359-4411, Zip: 12543
Mary Jones, 555-111-2211, Zip: 67891
Bill Smith, 555-769-8071, Zip: 54321

You can also use global arrays to return multiple values from a function as in this example: <lang> include "ConsoleWindow"

// Elements in global array _maxDim = 3

begin globals dim as Str31 gAddressArray(_maxDim, _maxDim) end globals

local fn FillRecord( array(_maxDim, _maxDim) as Str31 ) array( 0, 0 ) = "John Doe" array( 1, 0 ) = "Mary Jones" array( 2, 0 ) = "Bill Smith

array( 0, 1 ) = "555-359-4411" array( 1, 1 ) = "555-111-2211" array( 2, 1 ) = "555-769-8071"

array( 0, 2 ) = "12543" array( 1, 2 ) = "67891" array( 2, 2 ) = "54321" end fn

// Pass address of global array to fill it fn FillRecord( gAddressArray( 0, 0 ) )

dim as short i, j

for i = 0 to 2

  j = 0
  print gAddressArray(i, j    ); ", ";
  print gAddressArray(i, j + 1); ", Zip: ";
  print gAddressArray(i, j + 1)

next </lang>

Output:

John Doe, 555-359-4411, Zip: 555-359-4411
Mary Jones, 555-111-2211, Zip: 555-111-2211
Bill Smith, 555-769-8071, Zip: 555-769-8071

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

begin globals // An FB container can hold up to 2GB of data, contingent on system memory dim as container gC1, gC2 end globals

local fn ReturnMultipleValuesInContainers // Fill container with strings from inside function gC1 = "Twas brillig, and the slithy toves" + chr$(13) gC1 += "Did gyre and gimble in the wabe;" + chr$(13) gC1 += "All mimsy were the borogoves," + chr$(13) gC1 += "And the mome raths outgrabe." + chr$(13) gC1 += "'Beware the Jabberwock, my son!" + chr$(13) gC1 += "The jaws that bite, the claws that catch!" + chr$(13) gC1 += "Beware the Jubjub bird, and shun" + chr$(13) gC1 += "The frumious Bandersnatch!'" + chr$(13)

// Fill another container with numbers gC2 = "10254"+ chr$(13) gC2 += "37" + chr$(13) gC2 += "64" + chr$(13) end fn

local fn ReturnNewMultipleValuesInContainers gC1 = "Jabberwocky is gone, but here is some new text." + chr$(13) gC2 = "1000000" end fn

// Test to see containers are empty: print gC1 : print gC2

// Fill the containers using a function fn ReturnMultipleValuesInContainers

// Check results print gC1 : print : print gC2

// Empty the containers gC1 = "" : gC2 = ""

// Fill with another function fn ReturnNewMultipleValuesInContainers

// Check the new results print gC1 : print gC2 </lang>

Output:


Twas brillig, and the slithy toves
Did gyre and gimble in the wabe;
All mimsy were the borogoves,
And the mome raths outgrabe.
'Beware the Jabberwock, my son!
The jaws that bite, the claws that catch!
Beware the Jubjub bird, and shun
The frumious Bandersnatch!'

10254
37
64

Jabberwocky is gone, but here is some new text.

1000000

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

In this page you can see the program(s) related to this task and their results.

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>

<lang go>package main

import ( "fmt" )

// Return multiple values using a function func Pet(name, color string) (string, string) { color = "white" return name, color }

// Change multiple global values using a function and a struct type Beast struct { Cry, Play string }

var Fluffy = Beast{"Meow", "Mice"}

func myBeast() { Fluffy.Cry = "Hiss" // Fluffy.Play = "Ball" }

// Return multiple values using a function and an array func Cat(newCat []string) []string { newCat = append(newCat, "Milk") return newCat }

// Return multiple values using a method and a struct type Tabby struct { Sleep string Cry string }

func (myTab Tabby) Puss() (string, string) { myTab.Sleep = "Zzzz" myTab.Cry = "Purr" return myTab.Sleep, myTab.Cry }

func main() { // Return multiple values using a function name, color := Pet("Shadow", "Black") fmt.Println(name, color) // prt Puss Black

// Change multiple global values using a function and a struct // fmt.Println(Fluffy.Cry, Fluffy.Play) // prt Meow Mice myBeast() fmt.Println(Fluffy.Cry, Fluffy.Play) // prt Purr Ball

// Return multiple values using a function and an array newCat := make([]string, 2) newCat[0] = "Ginger" newCat[1] = "Orange" myPuss := Cat(newCat) fmt.Println(myPuss[1], myPuss[2]) // prt Orange Milk

// Return multiple values using a method and a struct myCat := Tabby{Sleep: "Snore", Cry: "Meow"} puss, poo := myCat.Puss() fmt.Println(puss, poo) // prt Kitty Cat }</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>

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:

<lang groovy>def addSub2(x,y) {

 [ x+y , x-y ]

}

def (sum, diff) = addSub2(50, 5) assert sum == 55 assert diff == 45</lang>

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.

Harbour

Every function returns one value. The conventional way to return multiple values is to bundle them into an array. <lang visualfoxpro>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 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. <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> Otherwise <lang Java>public class Values { private final Object[] objects; public Values(Object ... objects) { this.objects = objects; } public <T> T get(int i) { return (T) objects[i]; } public Object[] get() { return objects; }

// to test public static void main(String[] args) { Values v = getValues(); int i = v.get(0); System.out.println(i); printValues(i, v.get(1)); printValues(v.get()); } private static Values getValues() { return new Values(1, 3.8, "text"); } private static void printValues(int i, double d) { System.out.println(i + ", " + d); } private static void printValues(Object ... objects) { for (int i=0; i<objects.length; i+=1) System.out.print((i==0 ? "": ", ") + objects[i]); System.out.println(); } }</lang>

Output:

1
1, 3.8
1, 3.8, text

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. <lang JavaScript>//returns array with three values var arrBind = function () {

 return [1, 2, 3]; //return array of three items to assign

};

//returns object with three named values var objBind = function () {

 return {foo: "abc", bar: "123", baz: "zzz"};

};

//keep all three values var [a, b, c] = arrBind();//assigns a => 1, b => 2, c => 3 //skip a value var [a, , c] = arrBind();//assigns a => 1, c => 3 //keep final values together as array var [a, ...rest] = arrBind();//assigns a => 1, rest => [2, 3]

//same return name var {foo, bar, baz} = objBind();//assigns foo => "abc", bar => "123", baz => "zzz" //different return name (ignoring baz) 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"}</lang>

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: <lang jq># To produce a stream: def addsub(x; y): (x + y), (x - y);

To produce an array:

def add_subtract(x; y): [ x+y, x-y ]; </lang> The builtin filter .[] streams its input if the input is an array, e.g. the expression [1,2] | .[] produces the stream:<lang jq> 1 2</lang>

Julia

<lang julia>function addsub(x, y)

 return x + y, x - y

end</lang>

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

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. <lang scala>// version 1.0.6

/* implicitly returns a Pair<Int, Int>*/ fun minmax(ia: IntArray) = ia.min() to ia.max()

fun main(args: Array<String>) {

   val ia = intArrayOf(17, 88, 9, 33, 4, 987, -10, 2)
   val(min, max) = minmax(ia) // destructuring declaration
   println("The smallest number is $min")
   println("The largest  number is $max")

}</lang>

Output:

The smallest number is -10
The largest  number is 987

Lambdatalk

Lambdatalk can retun several values glued into conses or arrays. <lang scheme> {def foo

{lambda {:n}
 {cons {- :n 1} {+ :n 1}}}}       // two values

-> foo

{foo 10} -> (9 11)

{def bar

{lambda {:n}
 {A.new {- :n 1} :n {+ :n 1} }}}  // three values and more

-> bar

{bar 10} -> [9,10,11] </lang>

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

Lily

No support for returning multiple values, but (similar to Scala), a Tuple can be returned.

<lang Lily>define combine(a: Integer, b: String): Tuple[Integer, String] {

 return <[a, b]>

}</lang>

The current version (0.17) has no support for destructuring Tuple assigns.

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/Wolfram Language

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

- end_module addsub.</lang>

Use and output

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

Functions and tuples

Mercury is also a functional language, thus a function-based implementation is also possible. Functions in Mercury can only return a single value, but Mercury allows the use of arbitrary tuples containing multiple heterogeneous ad-hoc values which is, for all practical purposes, the same thing. The above code can be modified so that the definition of addsub/4 is now instead this function addsub/2:

<lang Mercury>:- func addsub(int, int) = {int, int}. addsub(X, Y) = { X + Y, X - Y }.</lang>

Instead, now, of a predicate with two input and two output parameters of type int, addsub is a function that takes two int parameters and returns a tuple containing two int values. The call to addsub/4 in the above code is now replaced by this:

<lang Mercury> {S, D} = addsub(X, Y),</lang>

All other code remains exactly the same as does the use and output of it.

Functions and type constructors

It should be noted that tuples as a construct are generally frowned upon in Mercury, relying as they do on structural type equivalence instead of nominative. The preferred approach is either to have multiple explicit output parameters on predicates or to have an explicit named type that covers the multi-return needs.

An example of this follows:

<lang Mercury>:- module addsub.

- interface.

- import_module io.

- pred main(io::di, io::uo) is det.

- implementation.

- import_module int, list, string.

- type my_result ---> twin(int, int).

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),
       twin(S, D) = addsub(X, Y),
       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)
   ).

- func addsub(int, int) = my_result.

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

- end_module addsub.</lang>

Here the type my_result has been provided with a twin/2 constructor that accepts two int values. Use and output of the code is, again, exactly the same.

addsub/2 explicitly constructs a my_result value with the paired calculations and this is deconstructed in the call in the main predicate through unification. While the resulting code is slightly more verbose than the tuple-based version it is more strongly protected against type errors and is more explicit in its intent at the same time.

min

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

Works with: min version 0.19.6

<lang min>(over over / '* dip) :muldiv</lang>

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>

Nim

Every function returns one value. We can return a tuple instead: <lang nim>proc addsub(x, y: int): (int, int) =

 (x + y, x - y)

var (a, b) = addsub(12, 15)</lang>

Or manipulate the parameters directly: <lang nim>proc addsub(x, y: int; a, b: var int) =

 a = x + y
 b = x - y

var a, b: int addsub(12, 15, a, b)</lang>

Objeck

Easiest way to return multiple values is to use in/out objects. The language also supports returning collections. <lang objeck>class Program {

 function : Main(args : String[]) ~ Nil {
   a := IntHolder->New(3); b := IntHolder->New(7);
   Addon(a,b);
   a->Get()->PrintLine(); b->Get()->PrintLine();
 }
 
 function : Addon(a : IntHolder, b : IntHolder) ~ Nil {
   a->Set(a->Get() + 2); b->Set(b->Get() + 13);
 }

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

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 : <lang Oforth>import: date

returnFourValues 12 13 14 15 ;

returnOneObject [ 12, 13, 14, 15, [16, 17 ], Date now, 1.2, "abcd" ] ;

"Showing four values returned on the parameter stack:" println returnFourValues .s clr

"\nShowing one object containing four values returned on the parameter stack:" println returnOneObject .s clr</lang>

Output:

Showing four values returned on the parameter stack:
[1] (Integer) 15
[2] (Integer) 14
[3] (Integer) 13
[4] (Integer) 12

Showing one object containing four values returned on the parameter stack:
[1] (List) [12, 13, 14, 15, [16, 17], 2016-02-05 20:55:15,778, 1.2, abcd]

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:

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

Phix

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

function stuff()
    return {"PI",'=',3.1415926535}
end function
{string what, integer op, atom val} = stuff()

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>

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 preg_match() which returns a boolean value (to determine if a match was found or not), but which modifies the $matches parameter supplied to hold all the capture groups.

You can achieve this simply by adding the & before the desired parameter: <lang php>function multiples($param1, &$param2) { if ($param1 == 'bob') { $param2 = 'is your grandmother'; return true; }

return false; }

echo 'First run: ' . multiples('joe', $y) . "\r\n"; echo "Param 2 from first run: '${y}'\r\n";

echo 'Second run: ' . multiples('bob', $y) . "\r\n"; echo "Param 2 from second run: '${y}'\r\n";</lang>

The above will yield the following output:

First run: 
Param 2 from first run: ''
Second run: 1
Param 2 from second run: 'is your grandmother'

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>

Plain English

Returning multiple values is natural. There are no limits to which parameters may be used for inputs and which parameters may be used for outputs. It's all the same to Plain English. You choose which slot(s) to put your return value(s) into.

Notice that the outputs actually come before the inputs in this case. (You could even have the outputs overwrite the inputs if you want.) In the calling scope, a product and a quotient introduce new local variables containing the values placed into them by the routine. <lang plainenglish>To run: Start up. Compute a product and a quotient given 15 and 3. Write "The product is " then the product on the console. Write "The quotient is " then the quotient on the console. Wait for the escape key. Shut down.

A product is a number.

To compute a product and a quotient given a number and another number: Put the number times the other number into the product. Put the number divided by the other number into the quotient.</lang>

Output:

The product is 45
The quotient is 5

PowerShell

<lang PowerShell> function multiple-value ($a, $b) {

   [pscustomobject]@{
       a = $a
       b = $b
   }

} $m = multiple-value "value" 1 $m.a $m.b </lang> Output:

value
1

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

Quackery

Words in Quackery take zero or more arguments from the data stack and leave zero or more results on the data stack.

We can demonstrate defining and using a word +*, which returns the sum and product of two numbers, in the Quackery shell.

Welcome to Quackery.

Enter "leave" to leave the shell.

/O> [ 2dup + unrot * ] is +* ( a b --> a+b a*b )
... 12 23 +*
... 

Stack: 35 276 

/O>

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>

Raku

(formerly Perl 6)

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:

<lang perl6>sub addmul($a, $b) {

   $a + $b, $a * $b

}

my ($add, $mul) = addmul 3, 7;</lang>

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

Raven

<lang Raven>define multiReturn use $v

  $v each

3 multiReturn</lang>

Output:

2
1
0

ReScript

<lang ReScript>let addsub = (x, y) => {

 (x + y, x - y)

}

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

Js.log2("33 + 12 = ", sum) Js.log2("33 - 12 = ", difference)</lang>

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 separated by blanks [or some other unique character(s) such as a comma,
semicolon, backslash, ···], it's a very simple matter to parse the multiple-value string into the desired
substrings (or values, if you will) with REXX's handy-dandy parse statement. <lang REXX>/*REXX program shows and displays examples of multiple RETURN values from a function.*/ numeric digits 70 /*the default is: NUMERIC DIGITS 9 */ parse arg a b . /*obtain two numbers from command line.*/ if a== | a=="," then a= 82 /*Not specified? Then use the default.*/ if b== | b=="," then b= 20 /* " " " " " " */ say ' a =' a /*display the first number to the term.*/ say ' b =' b /* " " second " " " " */ say copies('═', 50) /*display a separator line " " " */ z= arithmetics(a, b) /*call the function: arithmetics */ parse var z abut sum diff rem div Idiv prod pow /*obtain the function's returned values*/ say ' || =' abut /*display abutment to the terminal.*/ say ' + =' sum /* " sum " " " */ say ' - =' diff /* " difference " " " */ say ' // =' rem /* " remainder " " " */ say ' / =' div /* " quotient " " " */ say ' % =' Idiv /* " int. quotient " " " */ say ' * =' prod /* " product " " " */ say ' ** =' pow /* " power " " " */ 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</lang>

output when using the default inputs:

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

Ring

<lang ring> Func AddSub x,y

    Return [ x+y, x-y ]

</lang>

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>

Rust

Rust supports ADT, thus function can return tuple.

<lang rust>fn multi_hello() -> (&'static str, i32) {

   ("Hello",42)

}

fn main() {

   let (str,num)=multi_hello();
   println!("{},{}",str,num);

} </lang>

Output:

Hello,42

Scala

Every function returns one value. The conventional way to return multiple values is to return a tuple. <lang scala>def addSubMult(x: Int, y: Int) = (x + y, x - y, x * y)</lang> A more detailed declaration would be: <lang scala> def addSubMult(x: Int, y:Int) : (Int, Int, Int) = {

 ...
 (x + y, 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

SenseTalk

You can return multiple values in SenseTalk by returning a list, which can be assigned to multiple variables. <lang sensetalk>set [quotient,remainder] to quotientAndRemainder(13,4)

put !"The quotient of 13 ÷ 4 is: quotient with remainder: remainder"

to handle quotientAndRemainder of num, divisor return [num div divisor, num rem divisor] end quotientAndRemainder</lang>

Output:

The quotient of 13 ÷ 4 is: 3 with remainder: 1

Sidef

<lang ruby>func foo(a,b) {

   return (a+b, a*b);

}</lang>

Catching the returned arguments: <lang ruby>var (x, y) = foo(4, 5); say x; #=> 9 say y; #=> 20</lang>

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

<lang smalltalk>foo multipleValuesInto:[:a :b |

  Transcript show:a; cr.
  Transcript show:b; cr.

]</lang>

or: <lang smalltalk>|val1 val2| foo multipleValuesInto:[:a :b |

  val1 := a.
  val2 := b.

]. ... do something with val1 and val2... </lang>

The called method in foo looks like: <lang smalltalk> multipleValuesInto: aTwoArgBlock

  ...
  aTwoArgBlock value:<value1> value:<value2>

</lang> i.e. it invokes the passed-in lambda closure with the two (return-)values.

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>

Swift

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

 return (x + y, x - y)

}</lang> You can use pattern matching to extract the components: <lang swift>let (sum, difference) = addsub(33, 12) println("33 + 12 = \(sum)") println("33 - 12 = \(difference)")</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.

!/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:

x=5
y=6

Ursa

The most straightforward way to return multiple values from a function in Ursa is to return a stream.

This example gets a specified amount of strings from the user, then returns a stream containing them. <lang ursa>def getstrs (int n)

       decl string<> input

       while (> n 0)
               out ": " console
               append (in string console) input
               dec n
       end while

       return input

end getstrs

decl int amount out "how many strings do you want to enter? " console set amount (in int console)

decl string<> ret set ret (getstrs amount)

out endl ret endl console</lang>

Output:

how many strings do you want to enter? 5
: these   
: are
: some
: test
: strings

class java.lang.String<these, are, some, test, strings>

VBA

Firt way : User Defined Type <lang vb> Type Contact

   Name As String
   firstname As String
   Age As Byte

End Type

Function SetContact(N As String, Fn As String, A As Byte) As Contact

   SetContact.Name = N
   SetContact.firstname = Fn
   SetContact.Age = A

End Function

'For use : Sub Test_SetContact() Dim Cont As Contact

   Cont = SetContact("SMITH", "John", 23)
   Debug.Print Cont.Name & " " & Cont.firstname & ", " & Cont.Age & " years old."

End Sub </lang>

Output:

SMITH John, 23 years old.

Second way : ByRef argument : (Note : the ByRef Arg could be an array) <lang vb> Function Divide(Dividend As Integer, Divisor As Integer, ByRef Result As Double) As Boolean

   Divide = True
   On Error Resume Next
   Result = Dividend / Divisor
   If Err <> 0 Then
       Divide = False
       On Error GoTo 0
   End If

End Function

'For use : Sub test_Divide() Dim R As Double, Ddd As Integer, Dvs As Integer, B As Boolean

   Ddd = 10: Dvs = 3
   B = Divide(Ddd, Dvs, R)
   Debug.Print "Divide return : " & B & " Result = " & R
   Ddd = 10: Dvs = 0
   B = Divide(Ddd, Dvs, R)
   Debug.Print "Divide return : " & B & " Result = " & R

End Sub </lang>

Output:

Divide return : True Result = 3,33333333333333
Divide return : False Result = 1,#INF

Third way : ParramArray <lang vb> Function Multiple_Divide(Dividend As Integer, Divisor As Integer, ParamArray numbers() As Variant) As Long Dim i As Integer

   On Error GoTo ErrorHandler
   numbers(LBound(numbers)) = Dividend / Divisor
   For i = LBound(numbers) + 1 To UBound(numbers)
       numbers(i) = numbers(i - 1) / Divisor
   Next i
   Multiple_Divide = 1: Exit Function

ErrorHandler:

   Multiple_Divide = 0

End Function

'For use : Sub test_Multiple_Divide() Dim Arr(3) As Variant, Ddd As Integer, Dvs As Integer, L As Long, i As Integer

   Ddd = 10: Dvs = 3
   L = Multiple_Divide(Ddd, Dvs, Arr(0), Arr(1), Arr(2), Arr(3))
   Debug.Print "The function return : " & L
   Debug.Print "The values in return are : "
   For i = LBound(Arr) To UBound(Arr)
       Debug.Print Arr(i)
   Next i
   Erase Arr
   Debug.Print "--------------------------------------"
   Ddd = 10: Dvs = 0
   L = Multiple_Divide(Ddd, Dvs, Arr(0), Arr(1), Arr(2), Arr(3))
   Debug.Print "The function return : " & L
   Debug.Print "The values in return are : "
   For i = LBound(Arr) To UBound(Arr)
       Debug.Print IIf(Arr(i) = "", "vbNullString", "Null")
   Next i

End Sub </lang>

Output:

The function return : 1
The values in return are : 
 3,33333333333333 
 1,11111111111111 
 0,37037037037037 
 0,123456790123457 
--------------------------------------
The function return : 0
The values in return are : 
vbNullString
vbNullString
vbNullString
vbNullString

Fourth way : the variant() function <lang vb> Function List() As String() Dim i&, Temp(9) As String

   For i = 0 To 9
       Temp(i) = "Liste " & i + 1
   Next
   List = Temp

End Function

'For use : Sub test_List() Dim myArr() As String, i As Integer 'Note : you don't need to Dim your array !

   myArr = List()
   For i = LBound(myArr) To UBound(myArr)
       Debug.Print myArr(i)
   Next

End Sub </lang>

Output:

Liste 1
Liste 2
Liste 3
Liste 4
Liste 5
Liste 6
Liste 7
Liste 8
Liste 9
Liste 10

Visual FoxPro

!* Return multiple values from a function
!* The simplest way is to pass the parameters by reference
!* either by SET UDFPARMS TO REFERENCE, or prefix the variables with @.

LOCAL a, b a = 5 b = 6 ? "Sum =", AddUp(@a, @b) && Displays 11 ? "a =", a, "b =", b && Displays 4, 5 ? "Sum =", AddUp(@a, @b) && Displays 9

FUNCTION AddUp(n1, n2) LOCAL n n = n1 + n2 n1 = n1 - 1 n2 = n2 - 1 RETURN n ENDFUNC </lang>

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. <lang ecmascript>var splitName = Fn.new { |fullName| fullName.split(" ") }

var names = splitName.call("George Bernard Shaw") System.print("First name: %(names[0]), middle name: %(names[1]) and surname: %(names[2]).")</lang>

Output:

First name: George, middle name: Bernard and surname: Shaw.

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

Z80 Assembly

A function can return multiple values by altering the contents of multiple registers. Code is CALLed as a subroutine.

In this trivial example, the function returns 0xABCD and 0xFFFF. <lang z80>foo:

   ld hl,&ABCD
   ld bc,&FFFF
   ret</lang>

zkl

<lang zkl>fcn f{return(1,2,"three")} a,b,c:=f() // a==1, b==2, c=="three"</lang>