Variadic function: Difference between revisions

=={{header|ACL2}}==

(if (endp xs)

nil

(defmacro print-all (&rest args)

=={{header|ActionScript}}==

{

for (var i:int = 0; i < args.length; i++)

trace(args[i]);

=={{header|Ada}}==

Ada doesn't have variadic functions. But you can mimic the behavior by defining a function with an unconstrained array as its parameter, i.e., an array whose length is determined at run time.

procedure Variadic is

Print_Line((+"Mary", +"had", +"a", +"little", +"lamb.")); -- print five strings

Print_Line((1 => +"Rosetta Code is cooool!")); -- print one string

Output:<pre>Mary had a little lamb.

=={{header|Aime}}==

Printing strings:

f(...)

{

return 0;

Printing data of assorted types:

output_date(date d)

{

return 0;

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

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

MODE STRINT = UNION(STRING, INT, PROC(REF FILE)VOID, VOID);

print strint(("Mary","had",1,"little",EMPTY,new line))

Output:

<pre>

AppleScript handlers have no internal access to an argument vector, but we can use AppleScript's Patterned Parameters, in the form of lists of arbitrary length for variadic positional parameters, or records for variadic named parameters.

-- positionalArgs :: [a] -> String

end script

end if

{{Out}}

<pre>"alpha

=={{header|Applesoft BASIC}}==

An array of parameters with a count as parameter zero can be used in a subroutine to simulate a variadic function. The values in the array should probably be cleared when the subroutine returns because the array is a global variable.

20 P$(1) = "MARY"

30 P$(2) = "HAD"

70 GOSUB 90"VARIADIC FUNCTION

80 END

=={{header|Arturo}}==

; a quasi-variadic function

;-------------------------------------------

variable "yes"

{{out}}

{{works with|AutoHotkey_L}}

Writing an asterisk after the final parameter marks the function as variadic, allowing it to receive a variable number of parameters:

for k,v in args

t .= v "`n"

MsgBox, %t%

printAll(4, 3, 5)

Function arguments can be given default values. Comparison with "" can indicate that an argument was present (and not of value ""). As of version 1.0.48, you can pass more parameters than defined by a function, in which case the parameters are evaluated but discarded. Versions earlier than that produce warnings.

StringSplit, arg, string, %A_Space%

out .= arg%A_Index% "`n"

MsgBox,% out ? out:"No non-blank arguments were passed."

=={{header|AWK}}==

This f() can accept 0 to 3 arguments.

if (a != "") print a

if (b != "") print b

print "[2 args]"; f(1, 2)

print "[3 args]"; f(1, 2, 3)

<pre>[1 arg]

This f() can also accept array elements. This works because any missing array elements default to "", so f() ignores them.

if (a != "") print a

if (b != "") print b

# Pass to f().

f(ary[1], ary[2], ary[3])

<pre>Line 1

Functions like f() can take only a few arguments. To accept more arguments, or to accept "" as an argument, the function must take an array, and the caller must bundle its arguments into an array. This g() accepts 0 or more arguments in an array.

for (i = 1; i <= len; i++) print ary[i];

}

g(c, a) # Pass a[1] = "Line 1", a[4] = "", ...

<pre>Line 1

Variable argument lists are defined with the keyword '''VAR''', and are passed as an indexed array of strings. The number of elements is specified by a SIZE parameter. ''Arguments to functions could also simply be indexed or associative arrays or multiple element delimited strings.''

OPTION BASE 1

SUB demo (VAR arg$ SIZE argc)

demo("abc")

' Three arguments

{{out}}

The parameter list does not pass information about parameter type. If necessary, the type information has to be passed for example in the first parameter.

C calling convention has to be used (with keyword cdecl).

DIM arg AS Any Ptr

DIM i AS Integer

END SUB

For some reason, I was not able to get a Strings version of the above to work.

==={{header|FreeBASIC}}===

String version

' compile with: fbc -s console

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>only the last example shown

The existence of more parameters as well as the type of each parameter can be checked with function ITEM().

110 DO UNTIL ITEM()=0

120 IF ITEM()=1 THEN

200 printAll 3.1415, 1.4142, 2.71828

The code above is for Beta BASIC. There is a small difference between Beta BASIC and SAM BASIC.

=={{header|Batch File}}==

@echo off

:: Note: if _variadicfunc was called from cmd.exe with arguments parsed to it, it would only need to contain:

:: @for %%i in (%*) do echo %%i

{{out}}

<pre>

:c) the first element in the array specifies the number of arguments.

define f(a[], l) {

auto i

for (i = 1; i <= a[0]; i++) a[i]

=={{header|BCPL}}==

explicitly introduces this technique.

// A, B, C, etc are dummy arguments. If more are needed, more can be added.

// but you certainly needn't use them all.

let start() be

{{out}}

<pre>Mary

All BQN functions can be variadic since they allow taking lists of arbitrary length as arguments. A function can reject variadicity by defining a header to restrict the arguments to a specific length.

Fun2 ← {•Show¨𝕩}

Both <tt>Fun1</tt> and <tt>Fun2</tt> display all the values (arguments) of the lists given to them.

=={{header|C}}==

The ANSI C standard header <tt>stdarg.h</tt> defines macros for low-level access to the parameter stack. It does not know the number or types of these parameters; this is specified by the required initial parameter(s). For example, it could be a simple count, a terminating <tt>NULL</tt>, or a more complicated parameter specification like a printf() format string.

#include <stdarg.h>

}

In C, there is no way to call a variadic function on a list of arguments constructed at runtime.

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

class Program {

}

}

Output:

{{works with|g++|4.3.0}} using option -std=c++0x

template<typename T>

std::string s = "Hello world";

print("i = ", i, " and s = \"", s, "\"\n");

As the example shows, variadic templates allow any type to be passed.

=={{header|Clojure}}==

(doseq [a args]

(println a)))

(foo :bar :baz :quux)

=={{header|COBOL}}==

{{works with|Micro Focus COBOL V3.2}}

program-id. dsp-str is external.

data division.

.

end program dsp-str.

{{out}}

The [http://www.lispworks.com/documentation/HyperSpec/Body/03_dac.htm <tt>&rest</tt>] [http://www.lispworks.com/documentation/HyperSpec/Body/03_da.htm lambda list keyword] causes all remaining arguments to be bound to the following variable.

(dolist (arg args)

(print arg)))

(let ((args '("Mary" "had" "a" "little" "lamb")))

=={{header|Coq}}==

To define a variadic function, we build a variadic type:

Fixpoint Arity (A B: Set) (n: nat): Set := match n with

|O => B

|S n' => A -> (Arity A B n')

end.

This function can be used as a type, Arity A B n means <math>\underbrace{A \rightarrow \cdots \rightarrow A}_{\text{n times}} \rightarrow B</math> .

Since Arity is a type, we can compound it with itself as the destination to mean, for instance, "n naturals and 2 * n booleans" like so:

Definition nat_twobools (n: nat) := Arity nat (Arity bool nat (2*n)) n.

There is no equivalent to printf in Coq, because this function has border effects. We will then instead of printing each arguments build a list from it. <br \>

Finally, for the function to work, we need an accumulator of some sort

Require Import List.

Fixpoint build_list_aux {A: Set} (acc: list A) (n : nat): Arity A (list A) n := match n with

|S n' => fun (val: A) => build_list_aux (acc ++ (val :: nil)) n'

end.

Our function is then just an application of this one:

Definition build_list {A: Set} := build_list_aux (@nil A).

To call it we give it the number of argument and then the parameters we want in the list

Check build_list 5 1 2 5 90 42.

Which gives the result [1; 2; 5; 90; 42]

The reason for that is that the proof will be then a part of the type and computation of our function, so when we will try to compute it, Coq will be unable to unfold the opaque proof. Instead we should define our own lemmas and set their opacity to be transparent. Here are the two lemmas we will need:

Lemma transparent_plus_zero: forall n, n + O = n.

intros n; induction n.

- simpl; f_equal; rewrite IHn; reflexivity.

Defined.

Now on to the function. <br \>

Instead of defining a function directly, we will construct it as a proof that will be easier for us to write:

Require Import Vector.

- intros val. rewrite transparent_plus_S. apply IHn. (*Here we use the induction hypothesis. We just have to build the new accumulator*)

apply shiftin; [apply val | apply acc]. (*Shiftin adds a term at the end of a vector*)

As before, we can now build the full function with a null accumulator:

Definition build_vector {A: Set} (n: nat) := build_vector_aux n O (@nil A).

When we call it:

Require Import String.

Eval compute in build_vector 4 "Hello" "how" "are" "you".

Which gives the vector of members "Hello", "how", "are" and "you" of size 4

=={{header|D}}==

void printAll(TyArgs...)(TyArgs args) {

showSum1(1, 3, 50);

showSum2(1, 3, 50, 10);

{{out}}

<pre>4

=={{header|Dyalect}}==

for i in args {

print(i)

}

{{out}}

Variadic functions in the Déjà Vu standard library generally end with <code>(</code>, <code>[</code> or <code>{</code>. For this purpose, <code>)</code>, <code>]</code> and <code>}</code> are autonyms (that is, they have a global bindings to themselves, so that <code>)</code> is the same as <code>:)</code>).

while /= ) dup:

!.

drop

{{out}}

<pre>:foo

However, accepting any number of arguments can easily be done, as it is just a particular case of the basic mechanism for dynamic message handling:

match [`run`, args] {

for x in args {

example("Mary", "had", "a", "little", "lamb")

For comparison, a plain method doing the same thing for exactly two arguments would be like this:

to run(x, y) {

println(x)

println(y)

}

or, written using the function syntax,

println(x)

println(y)

=={{header|Egel}}==

Egel performs almost all of its work with pattern-matching anonymous functions which may match against any number of arguments. The following combinator discriminates between 2, 1, or 0 arguments; more elaborate examples are straightforward.

[ X Y -> "two" | X -> "one" | -> "zero" ]

=={{header|Elena}}==

ELENA 4.1 :

import extensions;

{

console.printAll("test", "rosetta code", 123, 5.6r)

{{out}}

<pre>

Elixir doesn't have the feature of the variable number of arguments.

However, it is possible to process as the list if putting in an argument in [].

def print_each( arguments ) do

Enum.each(arguments, fn x -> IO.inspect x end)

RC.print_each([1,2,3])

{{out}}

An <code>&rest</code> in the formal parameters gives all further arguments in a list, which the code can then act on in usual list ways. Fixed arguments can precede the <code>&rest</code> if desired.

(message "there are %d argument(s)" (length arg-list))

(dolist (arg arg-list)

(message "arg is %S" arg)))

A function can be called with a list of arguments (and optionally fixed arguments too) with <code>apply</code>, similar to most Lisp variants.

=={{header|Erlang}}==

Variable amount of anything (like arguments): use a list.

print_each( Arguments ) -> [io:fwrite( "~p~n", [X]) || X <- Arguments].

=={{header|Euler Math Toolbox}}==

>function allargs () ...

$ loop 1 to argn();

16

64

=={{header|Euphoria}}==

for i = 1 to length(args) do

puts(1,args[i])

end procedure

=={{header|Factor}}==

Variadic functions can be created by making a word which accepts a number specifying how many data stack items to operate on.

An interactive demonstration in the listener:

--- Data stack:

--- Data stack:

=={{header|Forth}}==

Words taking variable numbers of arguments may be written by specifying the number of parameters to operate upon as the top parameter. There are two standard words which operate this way: PICK and ROLL.

Alternatively, you can operate upon the entire parameter stack for debugging by using the word DEPTH, which returns the number of items currently on the stack.

=={{header|Fortran}}==

The following code shows how an optional vector argument can be used to pass a variable number of argument to a subroutine.

integer, dimension(:), allocatable :: va

end subroutine v_func

=={{header|Free Pascal}}==

Note, strictly speaking the routine <tt>writeLines</tt> has exactly ''one'' parameter.

{$mode objFPC}

begin

writeLines([42, 'is', true, #33]);

{{out}}

is

TRUE

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

=={{header|FutureBasic}}==

va_list ap

long value

fn Function2( @"One", @"Two", @"Three", @"O'Leary", NULL )

{{Out}}

<pre>987

A variadic function in Go has a <code>...</code> prefix on the type of the final parameter. [https://golang.org/ref/spec#Function_types (spec, Function types)]

// it's as if you declared "things" as a []string, containing all the arguments

for _, x := range things {

fmt.Println(x)

}

If you wish to supply an argument list to a variadic function at runtime, you can do this by adding a <code>...</code> ''after'' a slice argument:

=={{header|Golo}}==

----

This module demonstrates variadic functions.

# to call a variadic function with an array we use the unary function

unary(^varargsFunc)(args)

=={{header|Groovy}}==

Sample output:

=={{header|Haskell}}==

You can use some fancy recursive type-class instancing to make a function that takes an unlimited number of arguments. This is how, for example, printf works in Haskell.

process :: [String] -> t

main = do printAll 5 "Mary" "had" "a" "little" "lamb"

printAll 4 3 5

So here we created a type class specially for the use of this variable-argument function. The type class specifies a function, which takes as an argument some kind of accumulated state of the arguments so far, and returns the type of the type class. Here I chose to accumulate a list of the string representations of each of the arguments; this is not the only way to do it; for example, you could choose to print them directly and just accumulate the IO monad.

We need two kinds of instances of this type class. There is the "base case" instance, which has the type that can be thought of as the "return type" of the vararg function. It describes what to do when we are "done" with our arguments. Here we just take the accumulated list of strings and print them, one per line.

We actually wanted to use "IO ()" instead of "IO a"; but since you can't instance just a specialization like "IO ()", we used "IO a" but return "undefined" to make sure nobody uses it. Or we can use GADTs pragma and constraint in instance like this :

...

process args = do mapM_ putStrLn args

You can have multiple base case instances; for example, you might want an instances that returns the result as a string instead of printing it. This is how "printf" in Haskell can either print to stdout or print to string (like sprintf in other languages), depending on the type of its context.

varargs.icn

varargs("some", "extra", "args")

write()

procedure varargs(args[])

every write(!args)

Using it

=={{header|Io}}==

=={{header|J}}==

For example:

B=:3

C=:5

sum=:+/

sum 1,A,B,4,C

That said, J expects that members of lists all use the same kind of machine representation. If you want both character literals and numbers for arguments, or if you want arrays with different dimensions, each argument must be put into a box, and the function is responsible for dealing with the packing material.

commaAnd 'dog';A;B;'cat';C

To print each argument on its own line, we would typically map <code>echo</code> over the arguments (in this example, the contents of each box):

dog

2

3

cat

=={{header|Java}}==

{{works with|Java|1.5+}}

Using <tt>...</tt> after the type of argument will take in any number of arguments and put them all in one array of the given type with the given name.

// "things" is an Object[]

for(Object i:things){

System.out.println(i);

}

This function can be called with any number of arguments:

printAll(4, 3, 5);

Or with an array directly (the array must have the appropriate array type; i.e. if it is <tt>String...</tt>, then you need to pass a <tt>String[]</tt>):

But not with both (in this case the array is considered as just one of two arguments, and not expanded):

printAll(args, "Dude!");//does not print "Rosetta Code Is Awesome, Dude!"

In some rare cases, you may want to pass an array as just a single argument, but doing it directly would expand it to be the entire argument. In this case, you need to cast the array to <tt>Object</tt> (all arrays are objects) so the compiler doesn't know it's an array anymore.

=={{header|JavaScript}}==

===ES5===

The [https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Functions/arguments <code>arguments</code>] special variable, when used inside a function, contains an array of all the arguments passed to that function.

for (var i=0; i<arguments.length; i++)

print(arguments[i])

printAll(4, 3, 5, 6, 4, 3);

printAll(4, 3, 5);

The <code><var>function</var>.arguments</code> property is equivalent to the <code>arguments</code> variable above, but is deprecated.

You can use the <tt>apply</tt> method of a function to apply it to a list of arguments:

===ECMAScript 2015 (ES6) variants===

The newest version of ECMAScript added fat arrow function expression syntax, rest arguments and the spread operator. These make writing something like this easy. Of course, a better version might use Array.prototype.map, but here we have a variant that works on variadic arguments:

fix = // Variant of the applicative order Y combinator

f => (f => f(f))(g => f((...a) => g(g)(...a))),

// 13

// 14

Or, less ambitiously:

'use strict';

return printAll(1, 2, 3, 2 + 2, "five", 6);

{{Out}}

The first task requirement can in effect be accomplished using a 0-arity function defined as follows:

The parameters would be presented to <code>demo</code> in the form of an array. For example, given an array, args, constructed at runtime, the second task requirement can be accomplished by calling:

For example:

produces:

3.14

'''Variadic Function Names''':

In recent releases of jq (after version 1.4), function names are variadic in the sense that, if f is a function name, then f/n can be defined for multiple values of n. However, jq does not support the programmatic construction of function calls, and if a function is called with an undefined name/arity combination, then an error will be raised.

# arity-0:

def f: "I have no arguments";

# Example:

produces:

2

3

4

5

=={{header|Julia}}==

Putting <code>...</code> after the last argument in a function definition makes it variadic (any number of arguments are passed as a tuple):

julia> print_each(X...) = for x in X; println(x); end

hello

23.4

Conversely, when <code>...</code> is appended to an array (or other iterable object) passed to the function, the array is converted to a sequence of arguments:

julia> args = [ "first", (1,2,17), "last" ]

3-element Array{Any,1}:

(1,2,17)

last

=={{header|Klingphix}}==

1 tolist flatten

len [

stklen [split varfunc nl] if

=={{header|Kotlin}}==

fun variadic(vararg va: String) {

println()

variadic(*va)

Sample input/output:

{{out}}

=={{header|Ksh}}==

#!/bin/ksh

_variadic Mary had a little lamb

echo

{{out}}<pre>

Mary

=={{header|Lambdatalk}}==

Lambdas are de facto variadic in lambdatalk

{def foo

{lambda {:s}

10

=={{header|Lasso}}==

A Lasso method parameter name can prefixed by "..." to specify a variable number of parameters, which are made available as a staticarray. If no name is specified, the staticarray will be named "rest".

define printEachArg(...) => with i in #rest do stdoutnl(#i)

printArgs('a', 2, (:3))

To expand an existing list, pass it to the method using invocation syntax.

Output:

a

2

Code

Is

=={{header|Logo}}==

# an optional "rest" input (a list containing a colon prefixed word, set to the list of remaining arguments)

# ...with an optional default arity (a number)

foreach :args [print ?]

end

(varargs "Mary "had "a "little "lamb)

=={{header|Lua}}==

The generic syntax for defining a variadic function is appending an ellipsis to the list of arguments:

for i, v in ipairs{...} do print(v) end

It is then used like so:

{{out}}

<pre>1

When used with runtime arrays, the unpack function must be called on the array, otherwise the array itself will be used as the only argument:

=={{header|M2000 Interpreter}}==

Module's have stack too, but calling a module from module pass the same stack. This hold if we call function using Call statement.

Module CheckIt {

\\ Works for numbers and strings (letters in M2000)

}

Checkit2

=={{header|M4}}==

`ifelse($1,0,`',`$2

$0(decr($1),shift(shift($@)))')')dnl

define(`x',`1,2')

define(`y',`,3,4,5')

Output (with tracing):

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Function that takes 0 to infinite arguments and prints the arguments:

Example:

ShowMultiArg[a, b, c]

gives back:

a

5

3

In general Mathematica supports patterns in functions, mostly represented by the blanks and sequences: _, __ and ___ . With those you can create functions with variable type and number of arguments.

In MATLAB, the keyword "varargin" in the argument list of a function denotes that function as a variadic function. This keyword must come last in the list of arguments. "varargin" is actually a cell-array that assigns a comma separated list of input arguments as elements in the list. You can access each of these elements like you would any normal cell array.

for i = (1:numel(varargin))

end

Sample Usage:

1

4

=={{header|Maxima}}==

show(1, 2, 3, 4);

disp(1, 2, 3, 4);

=={{header|Metafont}}==

Variable number of arguments to a macro can be done using the <tt>text</tt> keyword identifying the kind of argument to the macro. In this way, each argument can be of any kind (here, as example, I show all the primitive types that Metafont knows)

for x = t:

if unknown x: message "unknown value"

print_arg("hello", x, 12, fullcircle, currentpicture, down, identity, false, pencircle);

=={{header|Modula-3}}==

Modula-3 provides the built ins <tt>FIRST</tt> and <tt>LAST</tt>, which can be used with <tt>FOR</tt> loops to cycle over all elements of an array. This, combined with open arrays allows Modula-3 to simulate variadic functions.

IMPORT IO;

BEGIN

Variable(strings);

Output:

<pre>

</pre>

Things get more complicated if you want to mix types:

IMPORT IO, Fmt;

strings^ := "Rosetta"; ints^ := 1; reals^ := 3.1415;

Variable(refarr);

Output:

<pre>

{{trans|C#}}

Like C#, Nemerle uses the <tt>params</tt> keyword to specify that arguments are collected into an array.

using System.Console;

PrintAll("test", "rosetta code", 123, 5.6, DateTime.Now);

}

=={{header|Nim}}==

for x in xs:

The function can be called with any number of arguments and the argument list can be constructed at runtime:

print 12, "Rosetta", "Code", 15.54321, "is", "awesome!"

let args = @["12", "Rosetta", "Code", "15.54321"]

=={{header|Objective-C}}==

Objective-C uses the same varargs functionality as C. Like C, it has no way of knowing the number or types of the arguments. When the arguments are all objects, the convention is that, if the number of arguments is undetermined, then the list must be "terminated" with <code>nil</code>. Functions that follow this convention include the constructors of data structures that take an undetermined number of elements, like <code>[NSArray arrayWithObjects:...]</code>.

void logObjects(id firstObject, ...) // <-- there is always at least one arg, "nil", so this is valid, even for "empty" list

// This function can be called with any number or type of objects, as long as you terminate it with "nil":

logObjects(@"Rosetta", @"Code", @"Is", @"Awesome!", nil);

=={{header|OCaml}}==

OCaml's strong type system makes writing variadic functions complex, as there is no <code>'a... -> 'b</code> type.

In general, writing a function that takes a list as argument is the best practice :

| [] -> ()

| x :: xs -> print_endline x; print xs

let () =

print [];

If you really need a true variadic function, there are a few ways to make it work.

The first is to specify the function's type with its first argument using a generalized algebraic data type (GADT) :

| Z : unit variadic

| S : 'a variadic -> (string -> 'a) variadic

print Z; (* no arguments *)

print (S Z) "hello"; (* one argument *)

You can even specify different types with more GADT constructors:

| Z : unit variadic

| U : 'a variadic -> (unit -> 'a) variadic

let () =

print (S (I (S Z))) "I am " 5 "Years old";

This is what the <code>Format.printf</code> functions do. The only difference is that the compiler constructs the GADT term from the given format string. This is why you can only call them with an explicit string argument, and not a variable of type string.

Another method uses continuation passing style (CPS) :

let arg value () cont = cont (Format.printf "%s\n" value)

let stop a = a

let () =

This isn't really a variadic function though, it's a hack that looks like one. The work is being done in the <code>arg</code> function, not <code>print</code>.

Other example (sequential composition or Lisp-like <code>apply</code>).

| Z : ('f,'f) t

| S : 'a -> (('a -> 'f), ('f,'g) t -> 'g) t

(* top level *)

=={{header|Oforth}}==

For instance :

{{out}}

=={{header|Oz}}==

This is only possible for methods, not for functions/procedures.

class Demo from BaseObject

meth test(...)=Msg

in

{D test(1 2 3 4)}

=={{header|PARI/GP}}==