Variadic function: Difference between revisions
m
{{header|F Sharp|F#}}
m ({{header|F Sharp|F#}}) |
|||
(39 intermediate revisions by 29 users not shown) | |||
Line 15:
=={{header|ACL2}}==
<
(if (endp xs)
nil
Line 22:
(defmacro print-all (&rest args)
`(print-all-fn (quote ,args)))</
=={{header|ActionScript}}==
<
{
for (var i:int = 0; i < args.length; i++)
trace(args[i]);
}</
=={{header|Ada}}==
Line 35:
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
Line 64:
Print_Line((+"Mary", +"had", +"a", +"little", +"lamb.")); -- print five strings
Print_Line((1 => +"Rosetta Code is cooool!")); -- print one string
end;</
Output:<pre>Mary had a little lamb.
Line 71:
=={{header|Aime}}==
Printing strings:
<
f(...)
{
Line 90:
return 0;
}</
Printing data of assorted types:
<
output_date(date d)
{
Line 123:
return 0;
}</
=={{header|ALGOL 68}}==
Line 135:
{{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);
Line 151:
print strint(("Mary","had",1,"little",EMPTY,new line))
)</
Output:
<pre>
Line 165:
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
Line 259:
end script
end if
end mReturn</
{{Out}}
<pre>"alpha
Line 275:
=={{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"
Line 283:
70 GOSUB 90"VARIADIC FUNCTION
80 END
90 FOR I = 1 TO VAL(P$(0)) : ? P$(I) : P$(I) = "" : NEXT I : P$(0) = "" : RETURN</
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">;-------------------------------------------
; a quasi-variadic function
;-------------------------------------------
variadic: function [args][
loop args 'arg [
print arg
]
]
; calling function with one block param
; and the arguments inside
;-------------------------------------------
; a function with optional attributes
;-------------------------------------------
variable: function [args][
print ["args:" args]
if? attr? "with" [
print ["with:" attr "with"]
]
else [
print "without attributes"
]
]
variable "yes"
variable.with:"something" "yes!"</syntaxhighlight>
{{out}}
<pre>one
2
three
args: yes
without attributes
args: yes!
with: something</pre>
=={{header|AutoHotkey}}==
{{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%
}</
This function can be called with any number of arguments:<
printAll(4, 3, 5)
printAll("Rosetta", "Code", "Is", "Awesome!")</
An array of parameters can be passed to any function by applying the same syntax to a function-call:<
printAll(args*)</
Line 319 ⟶ 344:
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%
Line 331 ⟶ 356:
out .= arg%A_Index% "`n"
MsgBox,% out ? out:"No non-blank arguments were passed."
}</
=={{header|AWK}}==
Line 338 ⟶ 363:
This f() can accept 0 to 3 arguments.
<
if (a != "") print a
if (b != "") print b
Line 348 ⟶ 373:
print "[2 args]"; f(1, 2)
print "[3 args]"; f(1, 2, 3)
}</
<pre>[1 arg]
Line 362 ⟶ 387:
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
Line 374 ⟶ 399:
# Pass to f().
f(ary[1], ary[2], ary[3])
}</
<pre>Line 1
Line 381 ⟶ 406:
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];
}
Line 389 ⟶ 414:
g(c, a) # Pass a[1] = "Line 1", a[4] = "", ...
}</
<pre>Line 1
Line 400 ⟶ 425:
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)
Line 415 ⟶ 440:
demo("abc")
' Three arguments
demo("123", "456", "789")</
{{out}}
Line 441 ⟶ 466:
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
Line 452 ⟶ 477:
END SUB
printAll 3, 3.1415, 1.4142, 2.71828</
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
Line 494 ⟶ 519:
Print : Print "hit any key to end program"
Sleep
End</
{{out}}
<pre>only the last example shown
Line 508 ⟶ 533:
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
Line 520 ⟶ 545:
200 printAll 3.1415, 1.4142, 2.71828
210 printAll "Mary", "had", "a", "little", "lamb",</
The code above is for Beta BASIC. There is a small difference between Beta BASIC and SAM BASIC.
Line 528 ⟶ 553:
=={{header|Batch File}}==
<
@echo off
Line 542 ⟶ 567:
:: 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
</syntaxhighlight>
{{out}}
<pre>
Line 556 ⟶ 581:
:c) the first element in the array specifies the number of arguments.
<
define f(a[], l) {
auto i
Line 573 ⟶ 598:
for (i = 1; i <= a[0]; i++) a[i]
}</
=={{header|BCPL}}==
BCPL does not have true variadic functions, however, it is explicitly legal
to pass a function the "wrong" amount of arguments. If fewer arguments are passed
than declared, the rest will remain uninitialized, if too many are passed,
the excess arguments are ignored. Additionally, it is guaranteed that the arguments will be located sequentially
in memory, starting from the first, making it possible to treat the address of the
first argument as if it is in fact an array of arguments.
These two facts together make it easy to declare a "variadic" function by
simply specifying a whole bunch of dummy arguments in the declaration, and then calling
the function later on with however many you happen to need. At least as many arguments as
you declare are guaranteed to make it through, though any more will not necessarily.
This technique is used in the standard library (this is how <code>writef</code>, the
equivalent to C's <code>printf</code>, is defined), and the book <cite>BCPL: The Language
and its Compiler</cite> by BCPL designer Martin Richards (which is as official as it gets)
explicitly introduces this technique.
<syntaxhighlight lang="bcpl">get "libhdr"
// A, B, C, etc are dummy arguments. If more are needed, more can be added.
// Eventually you will run into the compiler limit.
let foo(num, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) be
// The arguments can be indexed starting from the first one.
for i=1 to num do writef("%S*N", (@num)!i)
// You can pass as many arguments as you want. The declaration above guarantees
// that at least the first 16 arguments (including the number) will be available,
// but you certainly needn't use them all.
let start() be
foo(5, "Mary", "had", "a", "little", "lamb")</syntaxhighlight>
{{out}}
<pre>Mary
had
a
little
lamb</pre>
=={{header|BQN}}==
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.
<syntaxhighlight lang="bqn">Fun1 ← •Show¨
Fun2 ← {•Show¨𝕩}
Fun3 ← { 1=≠𝕩 ? •Show 𝕩; "too many arguments " ! 𝕩}</syntaxhighlight>
Both <tt>Fun1</tt> and <tt>Fun2</tt> display all the values (arguments) of the lists given to them.
<tt>Fun3</tt> throws an error if the given argument is not a list of length 1 or not a list at all. Otherwise it displays its argument.
=={{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>
Line 589 ⟶ 665:
}
varstrings(5, "Mary", "had", "a", "little", "lamb");</
In C, there is no way to call a variadic function on a list of arguments constructed at runtime.
Line 601 ⟶ 677:
=={{header|C sharp|C#}}==
<
class Program {
Line 613 ⟶ 689:
}
}
}</
Output:
Line 631 ⟶ 707:
{{works with|g++|4.3.0}} using option -std=c++0x
<
template<typename T>
Line 651 ⟶ 727:
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)
(apply foo [:bar :baz :quux])</
=={{header|COBOL}}==
{{works with|Micro Focus COBOL V3.2}}
<syntaxhighlight lang="text">
program-id. dsp-str is external.
data division.
Line 724 ⟶ 800:
.
end program dsp-str.
</syntaxhighlight>
{{out}}
Line 738 ⟶ 814:
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)))
Line 745 ⟶ 821:
(let ((args '("Mary" "had" "a" "little" "lamb")))
(apply #'example args))</
=={{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.
</syntaxhighlight>
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> .
Line 763 ⟶ 839:
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.
</syntaxhighlight>
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 \>
Line 774 ⟶ 850:
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
Line 780 ⟶ 856:
|S n' => fun (val: A) => build_list_aux (acc ++ (val :: nil)) n'
end.
</syntaxhighlight>
Our function is then just an application of this one:
<
Definition build_list {A: Set} := build_list_aux (@nil A).
</syntaxhighlight>
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.
</syntaxhighlight>
Which gives the result [1; 2; 5; 90; 42]
Line 798 ⟶ 874:
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.
Line 810 ⟶ 886:
- simpl; f_equal; rewrite IHn; reflexivity.
Defined.
</syntaxhighlight>
Now on to the function. <br \>
Line 817 ⟶ 893:
Instead of defining a function directly, we will construct it as a proof that will be easier for us to write:
<
Require Import Vector.
Line 825 ⟶ 901:
- 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*)
</syntaxhighlight>
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).
</syntaxhighlight>
When we call it:
<
Require Import String.
Eval compute in build_vector 4 "Hello" "how" "are" "you".
</syntaxhighlight>
Which gives the vector of members "Hello", "how", "are" and "you" of size 4
=={{header|D}}==
<
void printAll(TyArgs...)(TyArgs args) {
Line 862 ⟶ 938:
showSum1(1, 3, 50);
showSum2(1, 3, 50, 10);
}</
{{out}}
<pre>4
Line 879 ⟶ 955:
See for more info: http://dlang.org/function.html
=={{header|Delphi}}==
''See [[#Free Pascal|Free Pascal]].''
=={{header|Dyalect}}==
<
for i in args {
print(i)
Line 888 ⟶ 967:
}
printAll("test", "rosetta code", 123, 5.6)</
{{out}}
Line 901 ⟶ 980:
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
show-all( :foo "Hello" 42 [ true ] )</
{{out}}
<pre>:foo
Line 919 ⟶ 998:
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 {
Line 929 ⟶ 1,008:
example("Mary", "had", "a", "little", "lamb")
E.call(example, "run", ["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|Ecstasy}}==
Ecstasy does not support a true variadic function (<i>a la</i> C with "<tt>...</tt>") or a syntactic sugar for the same (<i>a la</i> Java with "<tt>...</tt>" and the underlying <tt>Object[]</tt>). Instead, when a variadic call is needed, the method or function is declared with the desired array type, and the caller simply passes an array value of any length using the literal array syntax:
<syntaxhighlight lang="java">
module VariadicFunction {
void show(String[] strings) {
@Inject Console console;
strings.forEach(s -> console.print(s));
}
void run() {
show(["hello", "world"]);
String s1 = "not";
String s2 = "a";
String s3 = "constant";
String s4 = "literal";
show([s1, s2, s3, s4]);
}
}
</syntaxhighlight>
{{out}}
<pre>
hello
world
not
a
constant
literal
</pre>
=={{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.
<syntaxhighlight lang="egel">
[ X Y -> "two" | X -> "one" | -> "zero" ]
</syntaxhighlight>
=={{header|Elena}}==
ELENA
<
import extensions;
Line 964 ⟶ 1,075:
printAll(params object[] list)
{
for(int i := 0
{
self.printLine(list[i])
Line 974 ⟶ 1,085:
{
console.printAll("test", "rosetta code", 123, 5.6r)
}</
{{out}}
<pre>
Line 986 ⟶ 1,097:
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)
Line 993 ⟶ 1,104:
RC.print_each([1,2,3])
RC.print_each(["Mary", "had", "a", "little", "lamb"])</
{{out}}
Line 1,011 ⟶ 1,122:
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)))
(my-print-args 1 2 3)</
A function can be called with a list of arguments (and optionally fixed arguments too) with <code>apply</code>, similar to most Lisp variants.
<
(apply 'message arg-list))</
=={{header|EMal}}==
<syntaxhighlight lang="emal">
^|EMal supports variadic functions in more than one way|^
fun print = void by text mode, List args do
writeLine("== " + mode + " ==")
for each var arg in args do writeLine(arg) end
end
fun printArgumentsList = void by List args
print("accepting a list", args)
end
fun printArgumentsUnchecked = void by some var args
print("unchecked variadic", args)
end
fun printArgumentsChecked = void by text subject, logic isTrue, int howMany, some text values
print("checked variadic", var[subject, isTrue, howMany, +values]) # unary plus on lists does list expansion
end
printArgumentsList(var["These are the ", true, 7, "seas", "of", "Rhye"])
printArgumentsUnchecked("These are the ", true, 7, "seas", "of", "Rhye")
printArgumentsChecked("These are the ", true, 7, "seas", "of", "Rhye")
</syntaxhighlight>
{{out}}
<pre>
== accepting a list ==
These are the
⊤
7
seas
of
Rhye
== unchecked variadic ==
These are the
⊤
7
seas
of
Rhye
== checked variadic ==
These are the
⊤
7
seas
of
Rhye
</pre>
=={{header|Erlang}}==
Variable amount of anything (like arguments): use a list.
<syntaxhighlight lang="erlang">
print_each( Arguments ) -> [io:fwrite( "~p~n", [X]) || X <- Arguments].
</syntaxhighlight>
=={{header|Euler Math Toolbox}}==
<syntaxhighlight lang="euler math toolbox">
>function allargs () ...
$ loop 1 to argn();
Line 1,047 ⟶ 1,203:
16
64
</syntaxhighlight>
=={{header|Euphoria}}==
<
for i = 1 to length(args) do
puts(1,args[i])
Line 1,057 ⟶ 1,213:
end procedure
print_args({"Mary", "had", "a", "little", "lamb"})</
=={{header|F Sharp|F#}}==
<syntaxhighlight lang="fsharp">
// Variadic function. Nigel Galloway: March 6th., 2024
open System
type X()=static member F([<ParamArray>] args: Object[]) = args|>Array.iter(printfn "%A")
X.F(23, 3.142, "Nigel", 1u, true)
</syntaxhighlight>
{{output}}
<pre>
23
3.142
Nigel
1
true
</pre>
=={{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:
Line 1,075 ⟶ 1,247:
--- Data stack:
"apple"</
=={{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.
<
4 3 2 1 4 sum . \ 10</
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}}==
Line 1,093 ⟶ 1,265:
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
Line 1,125 ⟶ 1,297:
end subroutine v_func
end program varargs</
=={{header|Free Pascal}}==
Note, strictly speaking the routine <tt>writeLines</tt> has exactly ''one'' parameter.
<
{$mode objFPC}
Line 1,167 ⟶ 1,339:
begin
writeLines([42, 'is', true, #33]);
end.</
{{out}}
<
is
TRUE
!</
=={{header|Fōrmulæ}}==
'''Solution'''
Fōrmulæ does not have variadic functions. However an array can be provided as argument:
'''Examples'''
Tee following function accepts a list as its unique parameter. It retrieves the list in vertical form (as a matrix of 1 column):
[[File:Fōrmulæ - Variadic function 01.png]]
[[File:Fōrmulæ - Variadic function 02.png]]
[[File:Fōrmulæ - Variadic function 03.png]]
[[File:Fōrmulæ - Variadic function 04.png]]
[[File:Fōrmulæ - Variadic function 05.png]]
With this approach we can use several parameters being lists with variable number of elements each, for example:
[[File:Fōrmulæ - Variadic function 06.png]]
[[File:Fōrmulæ - Variadic function 07.png]]
[[File:Fōrmulæ - Variadic function 08.png]]
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">void local fn Function1( count as long, ... )
va_list ap
long value
va_start( ap, count )
while ( count )
value = fn va_argLong( ap )
printf @"%ld",value
count--
wend
va_end( ap )
end fn
void local fn Function2( obj as CFTypeRef, ... )
va_list ap
va_start( ap, obj )
while ( obj )
printf @"%@",obj
obj = fn va_argObj(ap)
wend
va_end( ap )
end fn
window 1
// params: num of args, 1st arg, 2nd arg, etc.
fn Function1( 3, 987, 654, 321 )
print
// params: 1st arg, 2nd arg, ..., NULL
fn Function2( @"One", @"Two", @"Three", @"O'Leary", NULL )
HandleEvents</syntaxhighlight>
{{Out}}
<pre>987
654
321
One
Two
Three
O'Leary</pre>
=={{header|Go}}==
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:
<
printAll(args...)</
=={{header|Golo}}==
<
----
This module demonstrates variadic functions.
Line 1,220 ⟶ 1,462:
# to call a variadic function with an array we use the unary function
unary(^varargsFunc)(args)
}</
=={{header|Groovy}}==
<
printAll(1, 2, "three", ["3", "4"])</
Sample output:
Line 1,235 ⟶ 1,477:
=={{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
Line 1,251 ⟶ 1,493:
main = do printAll 5 "Mary" "had" "a" "little" "lamb"
printAll 4 3 5
printAll "Rosetta" "Code" "Is" "Awesome!"</
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 :
<
...
Line 1,262 ⟶ 1,504:
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.
Line 1,271 ⟶ 1,513:
varargs.icn
<
varargs("some", "extra", "args")
write()
Line 1,279 ⟶ 1,521:
procedure varargs(args[])
every write(!args)
end</
Using it
Line 1,291 ⟶ 1,533:
c
d</pre>
=={{header|Insitux}}==
<syntaxhighlight lang="insitux">(function f
(print (join "\n" args)))
(f 1 2 3 4)</syntaxhighlight>
=={{header|Io}}==
<
=={{header|J}}==
Line 1,301 ⟶ 1,549:
For example:
<
B=:3
C=:5
sum=:+/
sum 1,A,B,4,C
15</
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
dog, 2, 3, cat and 5</
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):
<syntaxhighlight lang="j"> echo&>'dog';A;B;'cat';C
dog
2
3
cat
5</syntaxhighlight>
=={{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);
printAll("Rosetta", "Code", "Is", "Awesome!");</
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>):
<
printAll(args);</
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!"
//instead prints the type and hashcode for args followed by "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.
<syntaxhighlight lang
=={{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])
Line 1,349 ⟶ 1,606:
printAll(4, 3, 5, 6, 4, 3);
printAll(4, 3, 5);
printAll("Rosetta", "Code", "Is", "Awesome!");</
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:
<
printAll.apply(null, args)</
===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))),
Line 1,387 ⟶ 1,644:
// 13
// 14
</syntaxhighlight>
Or, less ambitiously:
<
'use strict';
Line 1,402 ⟶ 1,659:
return printAll(1, 2, 3, 2 + 2, "five", 6);
})();</
{{Out}}
Line 1,418 ⟶ 1,675:
The first task requirement can in effect be accomplished using a 0-arity function defined as follows:
<syntaxhighlight lang
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:
<syntaxhighlight lang
For example:
<
produces:
<
3.14
[0,1,2]</
'''Variadic Function Names''':
Line 1,434 ⟶ 1,691:
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.
<syntaxhighlight lang="jq">
# arity-0:
def f: "I have no arguments";
Line 1,447 ⟶ 1,704:
# Example:
f, f(1), f(2;3), f(4;5;6)</
produces:
<
2
3
4
5
6</
=={{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
Line 1,465 ⟶ 1,722:
hello
23.4
</syntaxhighlight>
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}:
Line 1,478 ⟶ 1,735:
(1,2,17)
last
</syntaxhighlight>
=={{header|Klingphix}}==
<
1 tolist flatten
len [
Line 1,492 ⟶ 1,749:
stklen [split varfunc nl] if
nl "End " input</
=={{header|Kotlin}}==
<
fun variadic(vararg va: String) {
Line 1,511 ⟶ 1,768:
println()
variadic(*va)
}</
Sample input/output:
{{out}}
Line 1,531 ⟶ 1,788:
</pre>
=={{header|
<syntaxhighlight lang="ksh">
#!/bin/ksh
# Variadic function
# # Variables:
#
typeset -a arr=( 0 2 4 6 8 )
# # Functions:
#
function _variadic {
while [[ -n $1 ]]; do
print $1
shift
done
}
######
# main #
######
_variadic Mary had a little lamb
echo
_variadic ${arr[@]}</syntaxhighlight>
{{out}}<pre>
Mary
had
a
little
lamb
0
2
4
6
8</pre>
=={{header|Lambdatalk}}==
Lambdas are de facto variadic in lambdatalk
<syntaxhighlight lang="scheme">
{def foo
{lambda {:s} // :s will get any sequence of words
{S.first :s}
{if {S.empty? {S.rest :s}} then else {foo {S.rest :s}}}}}
-> foo
{foo hello brave new world}
-> hello brave new world
{foo {S.serie 1 10}}
-> 1 2 3 4 5 6 7 8 9 10
</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">
fp.printAll = (&values...) -> {
fn.arrayForEach(&values, fn.println)
}
fp.printAll(1, 2, 3)
# 1
# 2
# 3
fp.printAll() # No output
fp.printAll(abc, def, xyz)
# abc
# def
# xyz
# Array un-packing
&arr $= [1, abc, xyz, 42.42f]
fp.printAll(&arr...)
# 1
# abc
# xyz
# 42.42
fp.printAll(&arr..., last)
# 1
# abc
# xyz
# 42.42
# last
fp.printAll(first, &arr...)
# first
# 1
# abc
# xyz
# 42.42
</syntaxhighlight>
Solution with the use of arguments auto-pack operator and combinator function:
<syntaxhighlight lang="lang">
fp.printAllComb $= -|fn.combC(fn.arrayForEach, fn.println)
fp.printAllComb(42, 2, abc)
# 42
# 2
# abc
fp.printAllComb() # No output
&arr $= [1, abc, xyz, 42.42f]
fp.printAllComb(&arr...)
# 1
# abc
# xyz
# 42.42
</syntaxhighlight>
=={{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))
printEachArg('a', 2, (:3))</
To expand an existing list, pass it to the method using invocation syntax.
<
printEachArg(:#args)</
Output:
<
a
2
Line 1,578 ⟶ 1,923:
Code
Is
Awesome!</
=={{header|Logo}}==
Line 1,587 ⟶ 1,932:
# 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)
apply "varargs [Mary had a little lamb]</
=={{header|Lua}}==
Line 1,598 ⟶ 1,943:
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
end</
It is then used like so:
<
{{out}}
<pre>1
Line 1,613 ⟶ 1,958:
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:
<
varar(unpack(runtime_array));</
=={{header|M2000 Interpreter}}==
Line 1,629 ⟶ 1,974:
Module's have stack too, but calling a module from module pass the same stack. This hold if we call function using Call statement.
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
\\ Works for numbers and strings (letters in M2000)
Line 1,668 ⟶ 2,013:
}
Checkit2
</syntaxhighlight>
=={{header|M4}}==
<
`ifelse($1,0,`',`$2
$0(decr($1),shift(shift($@)))')')dnl
Line 1,680 ⟶ 2,025:
define(`x',`1,2')
define(`y',`,3,4,5')
showargs(x`'y)</
Output (with tracing):
Line 1,699 ⟶ 2,044:
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Function that takes 0 to infinite arguments and prints the arguments:
<
Example:
<
ShowMultiArg[a, b, c]
ShowMultiArg[5, 3, 1]</
gives back:
<
a
Line 1,715 ⟶ 2,060:
5
3
1</
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.
Line 1,721 ⟶ 2,066:
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))
Line 1,727 ⟶ 2,072:
end
end</
Sample Usage:
<
1
Line 1,739 ⟶ 2,084:
4
cat</
=={{header|Maxima}}==
<
show(1, 2, 3, 4);
Line 1,751 ⟶ 2,096:
disp(1, 2, 3, 4);
apply(disp, [1, 2, 3, 4]);</
=={{header|Metafont}}==
Line 1,757 ⟶ 2,102:
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"
Line 1,770 ⟶ 2,115:
print_arg("hello", x, 12, fullcircle, currentpicture, down, identity, false, pencircle);
end</
=={{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;
Line 1,789 ⟶ 2,134:
BEGIN
Variable(strings);
END Varargs.</
Output:
<pre>
Line 1,799 ⟶ 2,144:
</pre>
Things get more complicated if you want to mix types:
<
IMPORT IO, Fmt;
Line 1,824 ⟶ 2,169:
strings^ := "Rosetta"; ints^ := 1; reals^ := 3.1415;
Variable(refarr);
END Varargs.</
Output:
<pre>
Line 1,835 ⟶ 2,180:
{{trans|C#}}
Like C#, Nemerle uses the <tt>params</tt> keyword to specify that arguments are collected into an array.
<
using System.Console;
Line 1,849 ⟶ 2,194:
PrintAll("test", "rosetta code", 123, 5.6, DateTime.Now);
}
}</
=={{header|Nim}}==
<
for x in xs:
echo x</
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"]
print(args)</
=={{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
Line 1,880 ⟶ 2,225:
// 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);
logObjects(@4, @3, @"foo", 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 :
<syntaxhighlight lang="ocaml">let rec print = function
| [] -> ()
| x :: xs -> print_endline x; print xs
(* Or better yet *)
let print = List.iter print_endline
let () =
print [];
print ["hello"; "world!"]</syntaxhighlight>
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) :
<syntaxhighlight lang="ocaml">type 'a variadic =
| Z : unit variadic
| S : 'a variadic -> (string -> 'a) variadic
let rec print : type a. a variadic -> a = function
| Z -> ()
| S v -> fun x -> Format.printf "%s\n" x; print v
let () =
print Z; (* no arguments *)
print (S Z) "hello"; (* one argument *)
print (S (S (S Z))) "how" "are" "you" (* three arguments *)</syntaxhighlight>
You can even specify different types with more GADT constructors:
<syntaxhighlight lang="ocaml">type 'a variadic =
| Z : unit variadic
| U : 'a variadic -> (unit -> 'a) variadic
| S : 'a variadic -> (string -> 'a) variadic
| I : 'a variadic -> (int -> 'a) variadic
| F : 'a variadic -> (float -> 'a) variadic
(* Printing of a general type, takes pretty printer as argument *)
| G : 'a variadic -> (('t -> unit) -> 't -> 'a) variadic
| L : 'a variadic -> (('t -> unit) -> 't list -> 'a) variadic
let rec print : type a. a variadic -> a = function
| Z -> ()
| U v -> fun () -> Format.printf "()\n"; print v
| S v -> fun x -> Format.printf "%s\n" x; print v
| I v -> fun x -> Format.printf "%d\n" x; print v
| F v -> fun x -> Format.printf "%f\n" x; print v
| G v -> fun pp x -> pp x; print v
| L v -> fun pp x -> List.iter pp x; print v
let () =
print (S (I (S Z))) "I am " 5 "Years old";
print (S (I (S (L (S Z))))) "I have " 3 " siblings aged " (print (I Z)) [1;3;7]</syntaxhighlight>
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) :
<syntaxhighlight lang="ocaml">let print f = f ()
let arg value () cont = cont (Format.printf "%s\n" value)
let stop a = a
let () =
print stop;
print (arg "hello") (arg "there") stop;
(* use a prefix operator for arg *)
let (!) = arg
let () =
print !"hello" !"hi" !"its" !"me" stop</syntaxhighlight>
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>).
<syntaxhighlight lang="ocaml">type ('f,'g) t =
| Z : ('f,'f) t
| S : 'a -> (('a -> 'f), ('f,'g) t -> 'g) t
let rec apply: type f g. f -> (f,g) t -> g =
fun k t -> match t with
| Z -> k (* type g = f *)
| S x -> apply (k x) (* type g = (f,g) t -> g *)
let (!) x = S x (* prefix *)
(* top level *)
# apply List.map !(fun x -> x+1) ![1;2;3] Z</syntaxhighlight>
=={{header|Oforth}}==
Line 1,887 ⟶ 2,320:
For instance :
<
{{out}}
Line 1,901 ⟶ 2,334:
=={{header|Oz}}==
This is only possible for methods, not for functions/procedures.
<
class Demo from BaseObject
meth test(...)=Msg
Line 1,912 ⟶ 2,345:
in
{D test(1 2 3 4)}
{D Constructed}</
=={{header|PARI/GP}}==
Line 1,918 ⟶ 2,351:
{{Works with|PARI/GP|2.8+}}
<
{{Works with|PARI/GP|2.8.1+}}
<syntaxhighlight lang
=={{header|Pascal}}==
Line 1,931 ⟶ 2,364:
Functions in Perl 5 don't have argument lists. All arguments are stored in the array <tt>@_</tt> anyway, so there is variable arguments by default.
<
foreach (@_) {
print "$_\n";
}
}</
This function can be called with any number of arguments:
<
print_all(4, 3, 5);
print_all("Rosetta", "Code", "Is", "Awesome!");</
Since lists are flattened when placed in a list context, you can just pass an array in as an argument and all its elements will become separate arguments:
<
print_all(@args);</
Introduced '''experimentally''' in 5.20.0, subroutines can have signatures when the feature is turned on:
<
use experimental 'signatures';</
Perl policy states that all bets are off with experimental features—their behavior is subject to change at any time, and they may even be removed completely (''this feature will most likely stay in, but expect changes in the future that will break any scripts written using it as it stands in 5.20.1'').
Functions can be declared with fixed arity:
<
say $x, "\n", $y;
}</
But this can easily be converted to a variadic function with a slurpy parameter:
<
say "First: $first\n"
."Second: $second\n"
."And the rest: "
. join("\n", @rest);
}</
It is valid for the @rest array to be empty, so this is also an optional parameter (see [[Optional parameters]]).
=={{header|Phix}}==
{{libheader|Phix/basics}}
Copy of [[Variadic_function#Euphoria|Euphoria]]. The argument to print_args could be anything constructed at runtime. You can also specify optional parameters, simply by specifying a default value. Any non-optional arguments must be grouped together at the start.
<!--<syntaxhighlight lang="phix">-->
<span style="color: #008080;">procedure</span> <span style="color: #000000;">print_args</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">args</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">args</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">args</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">print_args</span><span style="color: #0000FF;">({</span><span style="color: #008000;">"Mary"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"had"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"a"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"little"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"lamb"</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
=={{header|Phixmonti}}==
<
1 tolist flatten
len for
Line 1,983 ⟶ 2,419:
"Mary" "had" "a" "little" "lamb" 5 tolist varfunc</
=={{header|PHP}}==
PHP 4 and above supports varargs. You can deal with the argument list using the <tt>func_num_args()</tt>, <tt>func_get_arg()</tt>, and <tt>func_get_args()</tt> functions.
<
function printAll() {
foreach (func_get_args() as $x) // first way
Line 1,999 ⟶ 2,435:
printAll(4, 3, 5);
printAll("Rosetta", "Code", "Is", "Awesome!");
?></
You can use the <tt>call_user_func_array</tt> function to apply it to a list of arguments:
<
$args = array("Rosetta", "Code", "Is", "Awesome!");
call_user_func_array('printAll', $args);
?></
{{works with|PHP|5.6+}}
You can receive variable arguments in a list by having a parameter preceded by <tt>...</tt>:
<
function printAll(...$things) {
foreach ($things as $x)
Line 2,017 ⟶ 2,453:
printAll(4, 3, 5);
printAll("Rosetta", "Code", "Is", "Awesome!");
?></
You can use the same <tt>...</tt> syntax to supply a list of arguments to a function:
<
$args = ["Rosetta", "Code", "Is", "Awesome!"];
printAll(...$args);
?></
=={{header|PicoLisp}}==
Line 2,032 ⟶ 2,468:
'[http://software-lab.de/doc/refA.html#arg arg]' and
'[http://software-lab.de/doc/refR.html#rest rest]' functions.
<
(while (args)
(println (next)) ) )</
The '@' operator may be used in combination with normal parameters:
<
(println Arg1)
(println Arg2)
(while (args)
(println (next)) ) )</
It is called like any other function
<
also by possibly applying it to a ready-made list
<
Output in all cases:
<pre>a
Line 2,052 ⟶ 2,488:
=={{header|PL/I}}==
<
/* argument list: */
s: procedure (a, b, c, d);
Line 2,060 ⟶ 2,496:
if ^omitted(c) then put skip list (c);
if ^omitted(d) then put skip list (d);
end s;</
=={{header|Plain English}}==
The only built-in imperative in Plain English that has variadic arguments is the 'call' imperative:
<syntaxhighlight lang="text">Call [dll name] [dll function] with [a value] and [another value].</syntaxhighlight>
The number of arguments used in the statement varies on the number of arguments needed by the DLL function. Variadic functions cannot be user-defined.
=={{header|PowerShell}}==
<
foreach ($x in $args) {
Write-Host $x
}
}</
Normal usage of the function just uses all arguments one after another:
<syntaxhighlight lang
In PowerShell v1 there was no elegant way of using an array of objects as arguments to a function which leads to the following idiom:
<
Invoke-Expression "& print_all $array"</
PowerShell v2 introduced the splat operator which makes this easier:
{{works with|PowerShell|2}}
<syntaxhighlight lang
=={{header|Prolog}}==
Line 2,099 ⟶ 2,540:
lists are often used instead of comma-lists to handle situations where
vararg-behavior is wanted. For example:
<
</syntaxhighlight>
To handle more esoteric situations, we could define a higher-order predicate to handle terms of arbitrary arity, e.g.
<
execute( Term ) :-
Term =.. [F | Args],
forall( member(X,Args), (G =.. [F,X], G, nl) ).
</syntaxhighlight>
<pre>
?- execute( write(1,2,3) ).
Line 2,117 ⟶ 2,558:
Putting <tt>*</tt> before an argument will take in any number of arguments and put them all in a tuple with the given name.
<
for x in things:
print x</
This function can be called with any number of arguments:
<
print_all(4, 3, 5)
print_all("Rosetta", "Code", "Is", "Awesome!")</
You can use the same "*" syntax to apply the function to an existing list of arguments:
<
print_all(*args)</
===Keyword arguments ===
Python also has keyword arguments were you can add arbitrary ''func('''''keyword1=value1, keyword2=value2 ...''''')'' keyword-value pairs when calling a function.
This example shows both keyword arguments and positional arguments. The two calls to the function are equivalent. '''*alist''' spreads the members of the list to create positional arguments, and '''**adict''' does similar for the keyword/value pairs from the dictionary.
<
print "POSITIONAL ARGS:\n " + "\n ".join(repr(x) for x in positionalargs)
print "KEYWORD ARGS:\n " + '\n '.join(
Line 2,157 ⟶ 2,598:
'fee' = 'fi'
'fo' = 'fum'
>>></
See the Python entry in [[Named_Arguments#Python|Named Arguments]] for a more comprehensive description of Python function parameters and call arguments.
Line 2,166 ⟶ 2,607:
puts all arguments into a list.
<syntaxhighlight lang="qi">
(define varargs-func
A -> (print A))
Line 2,175 ⟶ 2,616:
(sugar in varargs 1)
</syntaxhighlight>
=={{header|Quackery}}==
Line 2,183 ⟶ 2,624:
(<code>oats</code>: "'''o'''ne '''a'''nd '''t'''he '''s'''ame" compares the ''identity'' of two items, ensuring that <code>marker</code> is uniquely identified.)
<
[ echo$ cr ] ] is counted-echo$ ( $ ... n --> )
Line 2,200 ⟶ 2,641:
$ "this" $ "is" $ "a" $ "formica" $ "table" 5 counted-echo$
cr
marker $ "green" $ "is" $ "
{{out}}
Line 2,212 ⟶ 2,653:
green
is
its
colour
</pre>
Line 2,218 ⟶ 2,659:
=={{header|R}}==
This first function, almost completes the task, but the formatting isn't quite as specified.
<
printallargs1(1:5, "abc", TRUE)
# [[1]]
Line 2,227 ⟶ 2,668:
#
# [[3]]
# [1] TRUE</
This function is corrrect, though a little longer.
<
{
args <- list(...)
Line 2,238 ⟶ 2,679:
# [1] 1 2 3 4 5
# [1] "abc"
# [1] TRUE</
Use do.call to call a function with a list of arguments.
<
do.call(mean, arglist)</
=={{header|Racket}}==
Line 2,248 ⟶ 2,689:
function called "vfun".
<syntaxhighlight lang="racket">
-> (define (vfun . xs) (for-each displayln xs))
-> (vfun)
Line 2,264 ⟶ 2,705:
13
14
</syntaxhighlight>
=={{header|Raku}}==
Line 2,272 ⟶ 2,713:
If a subroutine has no formal parameters but mentions the variables <code>@_</code> or <code>%_</code> in its body, it will accept arbitrary positional or keyword arguments, respectively. You can even use both in the same function.
<syntaxhighlight lang="raku"
.say for @_;
say .key, ': ', .value for %_;
Line 2,278 ⟶ 2,719:
foo 1, 2, command => 'buckle my shoe',
3, 4, order => 'knock at the door';</
This prints:
Line 2,291 ⟶ 2,732:
Raku also supports slurpy arrays and hashes, which are formal parameters that consume extra positional and keyword arguments like <code>@_</code> and <code>%_</code>. You can make a parameter slurpy with the <code>*</code> twigil. This implementation of <code>&foo</code> works just like the last:
<syntaxhighlight lang="raku"
.say for @positional;
say .key, ': ', .value for %named;
}</
Unlike in Perl 5, arrays and hashes aren't flattened automatically. Use the <code>|</code> operator to flatten:
<syntaxhighlight lang="raku"
=={{header|RapidQ}}==
RapidQ uses special keywords SUBI and FUNCTIONI for procedures and functions with variable number of parameters.
Numeric parameters are accessed from array ParamVal and string parameters from array ParamStr$.
<
FOR i = 1 TO ParamValCount
PRINT ParamVal(i)
Line 2,314 ⟶ 2,755:
printAll 4, 3, 5, 6, 4, 3
printAll 4, 3, 5
printAll "Rosetta", "Code", "Is", "Awesome!"</
=={{header|REALbasic}}==
Line 2,320 ⟶ 2,761:
This subroutine prints it arguments. ParamArrays must be the last argument but may be preceded by any number of normal arguments.
<syntaxhighlight lang="vb">
Sub PrintArgs(ParamArray Args() As String)
For i As Integer = 0 To Ubound(Args)
Line 2,326 ⟶ 2,767:
Next
End Sub
</syntaxhighlight>
Calling the subroutine.
<syntaxhighlight lang="vb">
PrintArgs("Hello", "World!", "Googbye", "World!")
</syntaxhighlight>
=={{header|REBOL}}==
REBOL does not have variadic functions, nevertheless, it is easy to define a function taking just one argument, an ARGS block. The ARGS block contents can then be processed one by one:
<
Title: "Variadic Arguments"
]
Line 2,346 ⟶ 2,787:
]
print-all [rebol works this way]</
=={{header|REXX}}==
===simplistic===
<
do j=1 for arg()
say arg(j)
end /*j*/
return</
===annotated===
<
do j=1 for arg()
say '[argument' j"]: " arg(j)
end /*j*/
return</
===invocations===
The function can be called with any number of arguments (including no arguments and/or omitted arguments),
<br>although some REXX implementations impose a limit and the number of arguments.
<
call print_all "One ringy-dingy,",
Line 2,375 ⟶ 2,816:
"(Lily Tomlin routine)"
/* [↑] example showing multi-line arguments.*/</
===dynamically built argument list===
<
list=''
Do i=1 To 6
Line 2,389 ⟶ 2,830:
say arg(j)
end /*j*/
return</
Output:
<pre>arg1
Line 2,400 ⟶ 2,841:
=={{header|Ring}}==
<
# Project : Variadic function
Line 2,424 ⟶ 2,865:
svect = left(svect, len(svect) - 1)
see "" + svect + "]"
</syntaxhighlight>
Output:
<pre>
Line 2,430 ⟶ 2,871:
[1 2 3] 6
[1 2 3 4] 10
</pre>
=={{header|RPL}}==
Variable number of arguments are idiomatically passed through the stack, with the last argument specifying how many items shall be taken into account.
{{works with|HP|48G}}
≪ ""
1 ROT '''START'''
" " ROT + SWAP +
'''END''' TAIL
≫ '<span style="color:blue">MKLINE</span>' STO
"Mary" "has" "a" "little" "lamb" 5 <span style="color:blue">MKLINE</span>
{{out}}
<pre>
1: "Mary has a little lamb"
</pre>
=={{header|Ruby}}==
The * is sometimes referred to as the "splat" in Ruby.
<
puts things
end</
This function can be called with any number of arguments:
<
print_all(4, 3, 5)
print_all("Rosetta", "Code", "Is", "Awesome!")</
You can use the same "*" syntax to apply the function to an existing list of arguments:
<
print_all(*args)</
=={{header|Rust}}==
<syntaxhighlight lang="rust">// 20220106 Rust programming solution
macro_rules! print_all {
($($args:expr),*) => { $( println!("{}", $args); )* }
}
fn main() {
print_all!("Rosetta", "Code", "Is", "Awesome!");
}</syntaxhighlight>
Output: [https://tio.run/##PYy9CoMwAIT3PMUpDokIWocOlRZKp66@gIQ2lUB@JIm0IHn2VCt0uYPj@87NPqRU12ibtm0OzRH9umBydnRca2lGeKvmIK0hRPOHs4OblfDZikgTBq4UFgKAFrTgbvQn8Zkcq0qG8wULCrqDymQ0X2Je4UexDqxEBImEvAw0l4ay/ej/uwq99SIEvlr5zT7F1ne/5fUtvNUiy1lHYkpf Try it online!]
=={{header|Scala}}==
<
Example:
Line 2,474 ⟶ 2,942:
Putting a dot before the last argument will take in any number of arguments and put them all in a list with the given name.
<
(for-each
(lambda (x) (display x) (newline))
things))</
Note that if you define the function anonymously using <tt>lambda</tt>, and you want all the args to be collected in one list (i.e. you have no parameters before the parameter that collects everything), then you can just replace the parentheses altogether with that parameter, as if to say, let this be the argument list:
<
(lambda things
(for-each
(lambda (x) (display x) (newline))
things)))</
This function can be called with any number of arguments:
<
(print-all 4 3 5)
(print-all "Rosetta" "Code" "Is" "Awesome!")</
The <tt>apply</tt> function will apply the function to a list of arguments:
<
(apply print-all args)</
=={{header|Sidef}}==
A parameter declared with "*", can take any number of arguments of any type.
<
things.each { |x| say x };
}</
This function can be called with any number of arguments:
<
print_all(4, 3, 5);
print_all("Rosetta", "Code", "Is", "Awesome!");</
Also, there is "..." which transforms an array into a list of arguments.
<
print_all(args...);</
=={{header|Slate}}==
Line 2,513 ⟶ 2,981:
Putting an asterisk before a method's input variable header name means it will contain all non-core input variables (those are prefixed with a colon) in an Array.
<
printAll applyTo: #(4 3 5 6 4 3).
printAll applyTo: #('Rosetta' 'Code' 'Is' 'Awesome!').</
For method definitions and message sends, the same mechanism is employed, but the syntax for passing arguments after the message phrase is special (using commas to append arguments which fill <tt>*rest</tt>):
<
lobby printAll, 4, 3, 5, 6, 4, 3.
lobby printAll, 'Rosetta', 'Code', 'Is', 'Awesome!'.
</syntaxhighlight>
=={{header|Swift}}==
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 a [T]
for i in things {
print(i)
}
}</
This function can be called with any number of arguments:
<
printAll(4, 3, 5)
printAll("Rosetta", "Code", "Is", "Awesome!")</
=={{header|Tcl}}==
{{works with|Tcl|8.5}}
If the last argument is named "args", it collects all the remaining arguments
<
print_all 4 3 5 6 4 3
Line 2,549 ⟶ 3,017:
print_all $things ;# ==> incorrect: passes a single argument (a list) to print_all
print_all {*}$things ;# ==> correct: passes each element of the list to the procedure</
The above code will work in all versions of Tcl except for the last line. A version-independent transcription of that (one of many possible) would be:
<
=={{header|TIScript}}==
Line 2,557 ⟶ 3,025:
In TIScript last parameter of function may have '..' added to its name. On call that parameter will contain an array of rest of arguments passed to that function.
<
function printAll(separator,argv..) {
if(argv.length)
Line 2,566 ⟶ 3,034:
printAll(" ", 4, 3, 5, 6, 4, 3);
printAll(",", 4, 3, 5);
printAll("! ","Rosetta", "Code", "Is", "Awesome");</
=={{header|uBasic/4tH}}==
It's not easy to make a variadic function or procedure in uBasic/4tH, but it is possible with a little effort, provided the stack is used. However, sometimes it is required to reverse the order of the values by loading them into the array, from high memory to low memory. Strings may require even more effort, but the built-in hashing helps.
<syntaxhighlight lang="text">Push _Mary, _had, _a, _little, _lamb ' Push the hashes
Proc _PrintStrings (5) ' Print the string
Line 2,612 ⟶ 3,080:
_a Print "a"; : Return
_little Print "little"; : Return
_lamb Print "lamb"; : Return</
{{out}}
<pre>Mary had a little lamb
Line 2,623 ⟶ 3,091:
=={{header|Ursala}}==
<
#show+
main = f <'foo',12.5,('x','y'),100></
<code>f</code> is defined as a function that takes a list of any length of items of any type, and uses a built-in heuristic to decide how to print them. All functions in the language are polymorphic and variadic unless specifically restricted to the contrary.
Line 2,642 ⟶ 3,110:
Using a count as the indication of number of arguments to extract,
<
[zero? not] [swap puts pred]
while
].
100 200 300 400 500 3 myfn</
results in:
<
400
300</
=={{header|Visual Basic}}==
{{works with|Visual Basic|6}}
<
'--------------------------------------------------
Sub varargs(ParamArray a())
Line 2,694 ⟶ 3,162:
varargs v(2), v(1), v(0), 11
End Sub</
{{out}}
<pre>call 1
Line 2,720 ⟶ 3,188:
12
11</pre>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">fn print_all(things ...string) {
for x in things {
println(x)
}
}</syntaxhighlight>
=={{header|Vorpal}}==
Each method can have a variable-length parameter (VPL), indicated by empty brackets after the parameter name. The VLP (if present) will be replaced with an array containing all the extra arguments passed to the method. Effectively, extra arguments are absorbed into the array. Calling the function with fewer parameters than needed is still a runtime error. The VPL may be omitted, which will result in an empty array as the value of that parameter.
<
x.print()
for(i = 0, i < y.size(), i = i + 1){
Line 2,735 ⟶ 3,210:
self.f(1, 2, 3, 4)
'---'.print()
self.f(1, 2)</
=={{header|Wren}}==
Wren doesn't support variadic functions and doesn't really need to as we can just write a function which takes one (or one more) argument and pass it a list.
<
printArgs.call(["Mary", "had", "3", "little", "lambs"])</
{{out}}
Line 2,753 ⟶ 3,228:
=={{header|XLISP}}==
<
(for-each print xs))
Line 2,766 ⟶ 3,241:
; and then call APPLY:
(apply print-on-separate-lines test)</
{{out}}
<pre>I
Line 2,797 ⟶ 3,272:
=={{header|XPL0}}==
Passing an array is probably a better way to accomplish this task.
<
def IntSize=4; \number of bytes in an integer
Line 2,808 ⟶ 3,283:
];
Var(4, "Mary", "had", "a", "little")</
Output:
Line 2,820 ⟶ 3,295:
=={{header|zkl}}==
In zkl, all functions and methods are variadic (they are just passed a list).
<
f("Mary","had","a","little");</
{{output}}
<pre>
Line 2,829 ⟶ 3,304:
little
</pre>
<
f(a.xplode()); // xplode takes a list and blows it apart into call args</
{{output}}
<pre>
Line 2,838 ⟶ 3,313:
test
</pre>
<
g(a.xplode());</
pasteArgs takes the passed in function args and stuffs them back into the arglist of the function call
{{output}}
|