Named parameters: Difference between revisions
Content deleted Content added
Added Dyalect programming language |
m →{{header|Wren}}: Changed to Wren S/H |
||
(36 intermediate revisions by 24 users not shown) | |||
Line 13:
* [[wp:Named parameter|Wikipedia: Named parameter]]
<br><br>
=={{header|11l}}==
<syntaxhighlight lang="11l">F sqlen(x = 0, y = 0, z = 0)
R x*x + y*y + z*z
print(sqlen(z' 3)) // equivalent to print(sqlen(0, 0, 3))</syntaxhighlight>
=={{header|Ada}}==
All callable entities (procedures, functions, entries) require named arguments. All of them can be called using either positional or keyed association of the actual arguments. The arguments supplied with default values can be omitted.
<
It can be equivalently called as:
<
Foo (1);
Foo (Arg_2 => 0.0, Arg_1 => 1);
Foo (Arg_1 => 1);</
=={{header|ALGOL 68}}==
{{trans|Lua}}
<syntaxhighlight lang="algol68">BEGIN
MODE OPTNAME = STRUCT(STRING name),
OPTSPECIES = STRUCT(STRING species),
OPTBREED = STRUCT(STRING breed),
OWNER=STRUCT(STRING first name, middle name, last name);
# Version 2 of Algol 68G would not allow empty options to be specified as () so #
# VOID would need to be included in the MODEs for options and Empty option lists #
# would need to be written as (EMPTY) #
MODE OPTIONS = FLEX[1:0]UNION(OPTNAME,OPTSPECIES,OPTBREED,OWNER); # add ,VOID for Algol 68G version 2 #
# due to the Yoneda ambiguity simple arguments must have an unique operator defined #
# E.g. a string cannot be coerced to a structure with a single string field #
OP
BREED = (STRING breed)OPTBREED: (OPTBREED opt; breed OF opt := breed; opt);
PROC print pet = (
STRING name:="Rex", species:="Dinosaur", breed:="Tyrannosaurus"; # Defaults #
OWNER owner := ("George","W.","Bush");
FOR i TO UPB option DO
CASE option[i] IN
(OPTNAME option): name := name OF option,
(OPTSPECIES option): species := species OF option,
(OPTBREED option): breed := breed OF option,
(OWNER option): owner := option
ESAC
OD;
print(("Details: "
,IF CHAR c = breed[LWB breed]; char in string( c, NIL, "AaEeIiOoUu" ) THEN "an " ELSE "a " FI
,breed, " ", species, " named ",name," owned by ",owner, newline))
);
print pet((NAME "Mike", SPECIES "Dog", BREED "Irish Setter", OWNER("Harry", "S.", "Truman")));
print pet(()) # use print pet((EMPTY)) for Algol 68G version 2 #
END</syntaxhighlight>
Output:
<pre>
Details:
Details: a Tyrannosaurus Dinosaur named Rex owned by
</pre>
=={{header|AppleScript}}==
AppleScript does not implement default or optional parameters, but they can be simulated using records.
<
set {firstName, lastName} to {"?", "?"}
try
Line 72 ⟶ 84:
set lastName to x's lastName
end try
return firstName & ", " & lastName
end getName</syntaxhighlight>
Examples:
<
--> Returns: "John, Doe"
getName({lastName:"Doe"})
--> Returns: "?, Doe"</
----
An easier way to achieve the above is by concatenating a record containing default values for the expected properties to the record actually passed. The result will contain the labels and values from both records, except that where the same label exists in both records, there'll only be one instance in the result and its value will be that from the first record:
<syntaxhighlight lang="applescript">on getName(x) -- x assumed to be a record for this demo.
set x to x & {firstName:"?", lastName:"?"}
return x's firstName & ", " & x's lastName
end getName
getName({lastName:"Doe"})
--> "?, Doe"</syntaxhighlight>
One of AppleScript's handler types has long been "handlers with labeled parameters". These haven't proved particularly popular as they have a limited set of AppleScript-defined labels, which can require some creativity when choosing one to make sense in the script narrative. However, labelled parameters can be given in any order in calls:
<syntaxhighlight lang="applescript">on getName from firstName beside lastName
return firstName & ", " & lastName
end getName
getName beside "Doe" from "John"
--> "John, Doe"</syntaxhighlight>
However, it's also possible to define user labels, with the same flexibility of order, using a slightly different syntax:
<syntaxhighlight lang="applescript">on getName given firstName:firstName, lastName:lastName
return firstName & ", " & lastName
end getName
getName given lastName:"Doe", firstName:"John"
--> "John, Doe"</syntaxhighlight>
AppleScript-defined and user labels can be combined, but the AppleScript ones must be given first if used. The <tt>given</tt> syntax also has a neat feature whereby if the value to be passed is a boolean, the keyword <tt>with</tt> or <tt>without</tt> can be used instead in the call. In fact the compiler imposes this anyway when a boolean is hard-coded into the call:
<syntaxhighlight lang="applescript">on getName given firstName:firstName, lastName:lastName, comma:comma
if (comma) then
return firstName & ", " & lastName
else
return firstName & space & lastName
end if
end getName
getName given lastName:"Doe", firstName:"John" comma:true -- compiles as: getName with comma given lastName:"Doe", firstName:"John"
--> "John, Doe"
getName without comma given lastName:"Doe", firstName:"John"
--> "John Doe"</syntaxhighlight>
Since Mac OS X 10.10, it ''has'' been possible to make labelled parameters optional by defining default values for them in the handler declarations. But at least one parameter must be provided in any call:
<syntaxhighlight lang="applescript">use AppleScript version "2.4" -- Mac OS X 10.10 (Yosemite) or later.
on getName under category : "Misc: " given firstName:firstName : "?", lastName:lastName : "?", comma:comma : true
if (comma) then
return category & firstName & ", " & lastName
else
return category & firstName & space & lastName
end if
end getName
getName given lastName:"Doe"
--> "Misc: ?, Doe"</syntaxhighlight>
=={{header|Applesoft BASIC}}==
Function definitions in Applesoft BASIC using the DEF FN statement can only have one parameter. Subroutines and functions with many parameters can be simulated using global variables which are effectively named parameters. Default or optional parameters can be simulated with a check in the subroutine.
<
110 IF LAST$ < > "" THEN PRINT LAST$;
120 IF FIRST$ < > "" THEN PRINT ", "FIRST$;
200 FIRST$ = ""
210 LAST$ = ""
220 RETURN</
<pre>]FIRST$ = "JOHN" : GOSUB 100"PRINT NAME
Line 95 ⟶ 168:
]FIRST$ = "JOHN" : LAST$ = "DOE" : GOSUB 100"PRINT NAME
DOE, JOHN</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">func: function [x][
print ["argument x:" x]
print ["attribute foo:" attr 'foo]
print ["attribute bar:" attr 'bar]
print ""
]
func 1
func .foo:"foo" 2
func .bar:"bar" 3
func .foo:123 .bar:124 4
func .bar:124 .foo:123 5</syntaxhighlight>
{{out}}
<pre>argument x: 1
attribute foo: null
attribute bar: null
argument x: 2
attribute foo: foo
attribute bar: null
argument x: 3
attribute foo: null
attribute bar: bar
argument x: 4
attribute foo: 123
attribute bar: 124
argument x: 5
attribute foo: 123
attribute bar: 124</pre>
=={{header|AutoHotkey}}==
AutoHotkey doesn't have named parameters, but they can be simulated as follows.
ahk [http://www.autohotkey.com/forum/viewtopic.php?p=280499 discussion]
<
MyFunc( _overrides="" ) {
Static x=5, y=5, w=100, h=100, Count
Name:="AutoHotkey", Type:="Scripting", Text:="qwerty", Val:=True
Loop, Parse, _overrides,`,=, %A_Space% ; Override routine for Local/Static variables
A_Index & 1 ? (_:=A_LoopField) : (%_%:=A_LoopField)
Listvars
WinWaitClose, %A_ScriptFullPath%
}</
=={{header|Bracmat}}==
In Bracmat, all functions have exactly one argument, called "arg". To split the argument and assign values to local variables, you always have to use pattern matching.
In this task, the pattern is just made a bit more complex than would have been the case without explicit parameter names in the argument.
<
= i x y z
. out$"Calling testproc"
Line 134 ⟶ 244:
& testproc$((z,4) (x,2) (y,3)) { order is not important }
& testproc$((i,1) (y,2) (z,3))
);</
Output:
<pre>Calling testproc
Line 150 ⟶ 260:
{{works with|C99}}
<
// 1. Named parameters
Line 187 ⟶ 297:
FTest((FTest_args){ .y = 10, .z = 42 });
FT( .z = 47, .y = 10, .x = 42 );
// Default parameters
DFT();
DFT( .z = 99 );
// Default parameters with wrapper
DF2();
DF2( .z = 99 );
return 0;
}</
As a bonus, default values for the parameters left unspecified can be either implicitly set to zero by the struct initializer, or supplied in a wrapper-macro definition. But this is not idiomatic C by any stretch.
=={{header|C sharp|C#}}==
{{works with|C sharp|C#|4.0}}
Named parameters were added in C# 4.0. The examples below demonstrate how named parameters and optional parameters are a single concept in the language.
<syntaxhighlight lang="csharp">using System;
namespace NamedParams
{
class Program
{
static void AddWidget(string parent, float x = 0, float y = 0, string text = "Default")
{
Console.WriteLine("parent = {0}, x = {1}, y = {2}, text = {3}", parent, x, y, text);
}
static void Main(string[] args)
{
AddWidget("root", 320, 240, "First");
AddWidget("root", text: "Origin");
AddWidget("root", 500);
AddWidget("root", text: "Footer", y: 400);
}
}
}</syntaxhighlight>
Output:
<pre>parent = root, x = 320, y = 240, text = First
parent = root, x = 0, y = 0, text = Origin
parent = root, x = 500, y = 0, text = Default
parent = root, x = 0, y = 400, text = Footer</pre>
=={{header|C++}}==
Line 206 ⟶ 350:
You wrap the parameters in a class, and make the function a friend of the parameter class.
<
friend void foo(foo_params p);
public:
Line 230 ⟶ 374:
int required_param_;
int optional_x_;
int optional_y_;
float optional_z_;
};</
Declare the function to take the parameter class as its only parameter.
<
Call the function using the parameter object constructor with the required parameters and chaining the optional parameters.
<
{{libheader|Boost}}
If you want real named parameters you can use The Boost Parameter Library.
<
#include <boost/parameter/preprocessor.hpp>
#include <string>
Line 260 ⟶ 404:
tag, // part of the deep magic. If you use BOOST_PARAMETER_NAME you need to put "tag" here.
(required // names and types of all required parameters, parentheses are required.
(foo, (int))
(bar, (float))
)
Line 266 ⟶ 410:
(baz, (bool) , false)
(bonk, (std::string), "default value")
)
)
{
if (baz && (bar > 1.0)) return foo;
return bonk.size();
}</
Once the definition is written, using it is easy, by name or position.
<
function_with_named_parameters(7, _bar = 3.14);
function_with_named_parameters( _bar = 0.0, _foo = 42);
function_with_named_parameters( _bar = 2.5, _bonk= "Hello", _foo = 9);
function_with_named_parameters(9, 2.5, true, "Hello");</
=={{header|Clojure}}==
Line 319 ⟶ 429:
Clojure doesn't have built-in support for named or keyword arguments, but you can use destructuring to achieve a similar effect.
<
(let [opts (merge {:bar 1 :baz 2} (apply hash-map opts))
{:keys [bar baz]} opts]
[bar baz]))</
Clojure 1.2 supports destructuring of trailing arguments as a map:
<
[bar baz])</
You can also use <code>defnk</code> from <code>clojure.contrib.def</code>, which is a macro that works similarly.
<
(defnk foo [:bar 1 :baz 2]
[bar baz])</
Sample output for all variants:
Line 347 ⟶ 457:
=={{header|Common Lisp}}==
<
(princ last)
(when first
(princ ", ")
(princ first))
(values))</
<code>&key</code> indicates that further parameters are named (keyword parameters); a bare symbol (e.g. <var>first</var>) has a default of NIL, whereas a list (e.g. <code>(<var>last</var> "?")</code>) gives the variable name and the default value (which is evaluated when the function is called, unlike Python).
<
?
CL-USER> (print-name :first "John")
Line 363 ⟶ 473:
Doe, John
CL-USER> (print-name :last "Doe")
Doe</
In Common Lisp, the arguments to a function are always a simple list of values; the <code>&key</code> facility merely defines an interpretation of that list by the function: alternating keys and values. (As a result of this, mixing [[varargs]] (<code>&rest</code>) with named parameters is not recommended as it requires some additional means of distinguishing them. On the other hand, functions which pass their arguments on to other functions need not handle named arguments distinctly.)
{{omit from|D}}
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{Trans|C++}}
Delphi not support named params in any version, this is a uneficient, but functional, adaptation of c++ answer.
<syntaxhighlight lang="delphi">
program Named_parameters;
{$APPTYPE CONSOLE}
uses
System.SysUtils;
type
TParams = record
fx, fy, fz: Integer;
function x(value: Integer): TParams;
function y(value: Integer): TParams;
function z(value: Integer): TParams;
class function _: TParams; static;
end;
function Sum(Param: TParams): Integer;
begin
Result := Param.fx + Param.fy + Param.fz;
end;
{ TParams }
function TParams.x(value: Integer): TParams;
begin
Result := Self;
Result.fx := value;
end;
function TParams.y(value: Integer): TParams;
begin
Result := Self;
Result.fy := value;
end;
function TParams.z(value: Integer): TParams;
begin
Result := Self;
Result.fz := value;
end;
class function TParams._: TParams;
begin
Result.fx := 0; // default x
Result.fy := 0; // default y
Result.fz := 0; // default z
end;
begin
writeln(sum(TParams._.x(2).y(3).z(4))); // 9
writeln(sum(TParams._.z(4).x(3).y(5))); // 12
{$IFNDEF UNIX} readln; {$ENDIF}
end.</syntaxhighlight>
=={{header|Dyalect}}==
Line 373 ⟶ 544:
Dyalect supports both named and optional parameters.
<
print("x=\(x), y=\(y), z=\(z), dsc=\(dsc)")
}
fun(12, z: 24.4, dsc: "Foo", y: 3)
fun(y: 42, x: 12)</
{{out}}
Line 384 ⟶ 555:
<pre>x=12, y=3, z=24.4, dsc=Foo
x=12, y=42, z=12.2, dsc=Useless text</pre>
=={{header|E}}==
Since E supports arbitrary pattern matching (in the sense of [[Pattern Matching]] in parameter lists, a map-pattern can be used to provide named parameters, though the syntax is sufficiently noisy that this is not used casually.
<syntaxhighlight lang="e">def printName([=> first := null, => last := null]) {
if (last == null) {
print("?")
} else {
print(last)
}
if (first != null) {
print(", ")
print(first)
}
}</syntaxhighlight>
(Note: In map literals and map patterns, “<code>=> <var>x</var></code>” is shorthand for “<code>"<var>x</var>" => <var>x</var></code>”.)
<syntaxhighlight lang="e">? printName(["first" => "John"])
?, John
? printName(["last" => "Doe"])
Doe
? printName(["first" => "John", "last" => "Doe"])
Doe, John</syntaxhighlight>
=={{header|Ecstasy}}==
Method and function arguments are passed in order, unless argument names are specified by the caller. Both named arguments and default values for arguments are supported. Ordered and named arguments can both be used in the same invocation, but once a named argument is specified, all subsequent arguments in the invocation must also be named.
A common example of using named arguments is a "wither" method:
<syntaxhighlight lang="java">
module NamedParams {
const Point(Int x, Int y) {
Point with(Int? x=Null, Int? y=Null) {
return new Point(x ?: this.x, y ?: this.y);
}
}
@Inject Console console;
void run() {
Point origin = new Point(0, 0);
console.print($"origin={origin}");
Point moveRight = origin.with(x=5);
console.print($"moveRight(x=5)={moveRight}");
Point moveUp = moveRight.with(y=3);
console.print($"moveUp(y=3)={moveUp}");
}
}
</syntaxhighlight>
{{out}}
<pre>
origin=(x=0, y=0)
moveRight(x=5)=(x=5, y=0)
moveUp(y=3)=(x=5, y=3)
</pre>
=={{header|Elixir}}==
Line 389 ⟶ 619:
The easiest and visually most appealing way to have named parameters is using a proplist as last parameter of the function.
<syntaxhighlight lang="elixir">
def fun(bar: bar, baz: baz), do: IO.puts "#{bar}, #{baz}."
fun(bar: "bar", baz: "baz")
</syntaxhighlight>
For this way to use them, order matters, as well as you can't define default values for arguments.
Line 399 ⟶ 629:
=={{header|Erlang}}==
At a guess "named parameters" are supposed to be used like proplists in Erlang.
<syntaxhighlight lang="erlang">
Fun = fun( Proplists ) ->
Argument1 = proplists:get_value( argument1, Proplists, 1 ),
Line 405 ⟶ 635:
io:fwrite( "~p ~s~n", [Argument1, Kalle] )
end.
</syntaxhighlight>
The function can now be called like these examples.
Line 417 ⟶ 647:
</pre>
=={{header|
F# supports named method arguments directly. However they are not supported for functions, function values, or lambda functions.
This example comes from the F# documentation:
<syntaxhighlight lang="fsharp">
type SpeedingTicket() =
member this.GetMPHOver(speed: int, limit: int) = speed - limit
let CalculateFine (ticket : SpeedingTicket) =
let delta = ticket.GetMPHOver(limit = 55, speed = 70)
if delta < 20 then 50.0 else 100.0
let ticket1 : SpeedingTicket = SpeedingTicket()
printfn "%f" (CalculateFine ticket1)
</syntaxhighlight>
=={{header|Factor}}==
Line 448 ⟶ 668:
Named parameters in Factor are as simple as changing the <code>:</code> word to <code>::</code> and using the variables defined in the stack effect declaration.
<syntaxhighlight lang="factor">
:: my-named-params ( a b -- c ) a b * ;
</syntaxhighlight>
=={{header|Forth}}==
Line 458 ⟶ 678:
{{works with|Gforth}}
<
256 buffer: last-name
: is ( a "name" -- ) parse-name rot place ;
: greet ( -- )
cr ." Hello, " first-name count type space last-name count type ." !" ;
Line 470 ⟶ 690:
require mini-oof2.fs
require string.fs
object class
field: given-name
field: surname
end-class Person
: hiya ( -- )
cr ." Hiya, " given-name $. space surname $. ." !" ;
Person new >o s" Bob" given-name $! s" Hall" surname $! hiya o></
{{out}}<pre>Hello, Bob Hall!
Line 488 ⟶ 708:
Fortran accepts named parameter and optional parameter. Arguments are always named: if the name is omitted, the order used in the definition of the function / subroutine must be used.
<
integer, intent(in) :: arg1, arg2
integer, intent(out), optional :: arg3
! ...
end subroutine a_sub</
<
integer :: r
call a_sub(1,2, r)
call a_sub(arg2=2, arg1=1)</
The presence of an optional argument can be tested with <tt>PRESENT</tt>; if optional arguments come before a non optional argument, the usage of the name of the argument is mandatory.
<
integer, intent(in), optional :: arg1
integer, intent(in) :: arg2
!...
end subroutine b_sub</
<
call b_sub(arg2=1) ! ok
call b_sub(1, 2) ! ok: arg1 is 1, arg2 is 2
call b_sub(arg2=2, arg1=1) ! the same as the previous line</
=={{header|FreeBASIC}}==
{{trans|Visual Basic}}
<syntaxhighlight lang="freebasic">Dim Shared foo As Long, bar As Integer, baz As Byte, qux As String
'la función
Sub LoqueSea(foo As Long, bar As Integer, baz As Byte, qux As String)
'...
End Sub
'llamando a la función
Sub Algo()
LoqueSea(bar = 1, baz = 2, foo = -1, qux = "Probando")
End Sub</syntaxhighlight>
=={{header|Go}}==
Line 518 ⟶ 753:
Here's a simple example.
<
import (
Line 537 ⟶ 772:
t := myFunc(params{y: 2}) // only one field, others set to zero
fmt.Println("t =", t)
}</
{{out}}
Line 549 ⟶ 784:
We can simulate named, but not moveable arguments, with nullary data constructors:
<
data Y = Y
data Point = Point Int Int deriving Show
Line 556 ⟶ 791:
createPointAt X x Y y = Point x y
main = print $ createPointAt X 5 Y 3</
We can also emulate named, moveable, optional arguments with record syntax:
<
defaultPoint = Point {x = 0, y = 0}
createPointAt :: Point -> Point
createPointAt = id
main = print $ createPointAt (defaultPoint { y = 3, x = 5 })</
Though this is cumbersome without using template Haskell, as the call site must supply the defaults.
Line 578 ⟶ 813:
<
testproc("x:=",1,"y:=",2,"z:=",3)
testproc("x:=",3,"y:=",1,"z:=",2)
Line 593 ⟶ 828:
((variable(a[1:-2]) := get(A)) | # assign
runerr(205,a))) # . . problem
write(" x:=",x)
write(" y:=",y)
write(" z:=",z)
end</
{{improve|Icon|there is currently a bug in Icon that causes assignments via variable("x") to fail for local and static variables. Remove this when this is fixed. The bug does not appear in Unicon.}}
Line 619 ⟶ 854:
J is similar to Perl in that all arguments to functions come in as separate elements in an array. But it is possible to emulate more complex calling conventions. For example, using the [http://www.jsoftware.com/svn/DanBron/trunk/environment/calling_convention.ijs calling convention J script], one could write:
<
myFunc['c:\file.txt' 906 'blue' fs]
NB. Commas, like other langs
myFunc['c:\file.txt', 906, 'blue' fs]
NB. Unspecified args are defaulted ("optional")
myFunc['c:\file.txt' fs]
NB. Can use named arguments, like eg VB
myFunc[color='blue' fs]
NB. Often values needn't be quoted
myFunc[color= blue fs]
NB. Combination of comma syntax and name=value
myFunc[max=906, color=blue fs]
NB. Spelling of names is flexible
myFunc[MAX=906, COLOR=blue fs]
Line 642 ⟶ 877:
NB. Order of names is flexible
myFunc[COLOR=blue, MAX=906 fs]
NB. Even the delimiters are flexible...
myFunc<MAX=906, COLOR=blue fs></
For further discussion, see the [http://www.jsoftware.com/pipermail/programming/2009-July/015571.html corresponding thread in the J Forums].
Line 650 ⟶ 885:
=={{header|Java}}==
Like C++, Java also does not support named parameters. Named parameters can however be simulated simply with the "Builder pattern". ([http://drdobbs.com/java/208403883?pgno=2 Joshua Bloch: Builder Pattern])
<
Follow the link for extra details about the 'NutritionFacts' class example.
=={{header|JavaScript}}==
JavaScript only has positional parameters, but named parameters can be emulated by passing an object with the appropriate properties:
<
// assign some defaults where the user's has not provided a value
opts = {}
Line 666 ⟶ 901:
example({grill: "lamb kebab", bar: 3.14});
// => "foo is 0, bar is 3.14, and grill is lamb kebab"</
===ECMAScript 2015 (ES6) variants===
With this version, ECMAScript adds destrucuring assignments and destructuring in function parameters. Thus you could do something like this (this works in ES6 Fiddle, but is syntax error in Mozilla SpiderMonkey JS Shell, so uses console.log instead of print):<
example = // The member name in the object can either be the same as the parameter (as in bar, grill),
// or a different parameter name as in the case of member foo being assigned to parameter a here.
Line 679 ⟶ 914:
// foo is 0 , bar is 3.14 , and grill is lamb kebab
example({foo:null});
// foo is , bar is 1 , and grill is pork chops</
=={{header|jq}}==
Line 685 ⟶ 920:
For example, here is the jq analog of "print-name" defined in the Common Lisp section above. Here we format the full name and return it as a string:
<syntaxhighlight lang="jq">
def formatName(obj):
({ "name": "?"} + obj) as $obj # the default default value is null
| ($obj|.name) as $name
| ($obj|.first) as $first
| if ($first == null) then $name
else $name + ", " + $first
end;
</syntaxhighlight>
Here are examples of how the function can be invoked:
<syntaxhighlight lang
formatName({"first": "George", "name": "Eliot"})
Line 706 ⟶ 941:
formatName({})
</syntaxhighlight>
=={{header|Julia}}==
Julia supports arbitrary named keyword arguments, which are listed (with their default values) after a <code>;</code> in the function definition:
<
ve, ho, ul, ur, dl, dr =
border == :round ? ("\u2502","\u2500","\u256d","\u256e","\u2570","\u256f") :
border == :bold ? ("\u2503","\u2501","\u250F","\u2513","\u2517","\u251b") :
border == :double ? ("\u2551","\u2550","\u2554","\u2557","\u255a","\u255d") :
border == :dotted ? ("\u254e","\u254c","\u250c","\u2510","\u2514","\u2518") :
border == :cross ? ("\u2502","\u2500","\u253c","\u253c","\u253c","\u253c") :
("\u2502","\u2500","\u250c","\u2510","\u2514","\u2518")
println(ul, ho^(length(string) + 2padding), ur, "\n",
ve, " "^padding, string," "^padding, ve, "\n",
dl, ho^(length(string) + 2padding), dr)
end</
{{Out}}
Line 737 ⟶ 972:
=={{header|Kotlin}}==
<
fun someFunction(first: String, second: Int = 2, third: Double) {
Line 745 ⟶ 980:
fun main(args: Array<String>) {
// using positional parameters
someFunction("positional", 1, 2.0)
// using named parameters
Line 754 ⟶ 989:
// using first and third parameters in reverse
someFunction(third = 2.0, first = "reversed")
}</
{{out}}
Line 765 ⟶ 1,000:
</pre>
=={{header|
Function calls in LabVIEW are implemented as instantiated VIs, small icons representing the function to be called. All parameters are positional, by drawing wires to different points along the icon edge. By right-clicking on the VI icon and unchecking "View as Icon", the parameter names can be shown. The parameter names are mainly informational for the user.
Line 774 ⟶ 1,009:
=={{header|Lasso}}==
<
-first::integer, // with no default value the param is required
-second::integer,
Line 789 ⟶ 1,024:
-first = 54,
-delimiter = '#'
)</
-> 54:45
Line 796 ⟶ 1,031:
=={{header|Lingo}}==
Lingo does not support named function parameters. But this can be simulated by using a single property list (hash) with named properties as function argument. You can also create functions that support both calling methods, like e.g. this function that accepts either 3 integers or a single property list with such named properties:
<
on foo (arg1, arg2, arg3)
if ilk(arg1)=#propList then
Line 817 ⟶ 1,052:
-- "arg1="
-- "arg2="
-- "arg3=3"</
=={{header|Lua}}==
<syntaxhighlight lang="lua">
function CreatePet(options)
local name=options.name
Line 829 ⟶ 1,064:
CreatePet{name='Rex',species='Dog',breed='Irish Setter'}
--position does not matter here.
</syntaxhighlight>
=={{header|M2000 Interpreter}}==
Line 835 ⟶ 1,070:
Passing optionals in modules may cause problems if we have values in stack, so we can use Stack New {] to open an empty current stack (the old one is hidden until exit from that block), or using ? as "use standard value".
<syntaxhighlight lang="m2000 interpreter">
module namedparam (x as decimal=10, y as integer=50) {
Print type$(x), x
Line 850 ⟶ 1,085:
}
namedparam %x=1, %y=1
</syntaxhighlight>
=={{header|Maple}}==
<
print (a*(c+b));
end proc:
Line 862 ⟶ 1,097:
3
f(2, b = 5, c = 3);#b and c can be put in any order
16</
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
fn[x_,y_,OptionsPattern[]]:=If[OptionValue[Add]==True,x+y+OptionValue[Offset],{x,y,OptionValue[Offset]}]
fn[3,4,{Add->True,Offset->2}]
fn[3,4,{Offset->2,Add->True}]</syntaxhighlight>
{{out}}
<pre>9
9</pre>
=={{header|MATLAB}} / {{header|Octave}}==
Line 877 ⟶ 1,112:
Named parameters are not natively supported. However, the following code can be used to implement them.
<syntaxhighlight lang
for k= 1:2:length(varargin);
switch (varargin{k})
Line 884 ⟶ 1,119:
case {'param2'}
param2 = varargin{k+1};
end;
end;
printf('param1: %s\n',param1);
printf('param2: %s\n',param2);
end;
foo('param1','a1','param2','b2');
Output:
<pre>>> foo('param1','a1','param2','b2');
param1: a1
param2: b2
>> foo('param2','b2','param1','a1');
param1: a1
param2: b2</pre>
=={{header|Modula-3}}==
Much like [[Ada]], Modula-3 allows either positional or keyed association of actual parameters. Defaults can also be ignored.
<
It can be equivalently called as:
<
Foo(1);
Foo(Arg2 := 0.0, Arg1 := 1);
Foo(Arg1 := 1);</
=={{header|Nemerle}}==
<
Foo(word = "Bird", number = 3) // an argument with a default value can be omitted from function call
Foo(3, option = false, word = "Bird") // unnamed arguments must be in same order as function definition and precede named arguments
</syntaxhighlight>
=={{header|Nim}}==
In Nim, a regular parameter of a procedure can be used as either a positional or a named parameter.
<
echo subtract(5, 3) # used as positional parameters
echo subtract(y = 3, x = 5) # used as named parameters</
Parameters can be made optional by providing a default argument.
=={{header|Objective-C}}==
Objective-C, like Smalltalk, has a method call syntax that is visually identical to named arguments, but they are not optional and may not be reordered. (Optional arguments may be simulated by defining multiple methods with the same leading name part.)
<
// Omitted ...
}
Line 936 ⟶ 1,172:
- (double) hypotenuseOfX: (double)x andY: (double)y andZ: (double)z;
@end</
<
- (double) hypotenuseOfX: (double)x andY: (double)y {
Line 946 ⟶ 1,182:
}
@end</
<
double h = [example hypotenuseOfX:1.23 andY:3.79];</
Note in the example above that the name of the method, the ''selector''; is actually “<code>hypotenuseOfX:andY:</code>”.
=={{header|OCaml}}==
You can make a named argument (called ''labels'' in OCaml) by putting a tilde (~) before the name:
<
val foo : arg1:int -> arg2:int -> int = <fun>
# let foo ~arg1:x ~arg2:y = x + y;; (* you can also use different variable names internally if you want *)
val foo : arg1:int -> arg2:int -> int = <fun>
# foo ~arg2:17 ~arg1:42;;
- : int = 59</
Named arguments can be re-ordered, but two arguments of the same label cannot be re-ordered relative to each other.
Line 968 ⟶ 1,206:
=={{header|Oz}}==
For <b>methods</b>, Oz does support named parameters with default values. The named parameters can be freely reordered.
<
class Foo
meth init skip end
Line 982 ⟶ 1,220:
{O bar(1 named1:2 named2:3 namedWithDefault:4)} %% ok
{O bar(1 named2:2 named1:3)} %% ok
{O bar(1 named1:2)} %% not ok, "missing message feature in object application"</
For <b>procedures</b> only positional parameters are supported. However, you can emulate named parameters by using records:
<syntaxhighlight lang="oz">
declare
proc {Foo PP Other=unit(named1:N1 named2:N2 ...)}
Line 995 ⟶ 1,233:
{Foo 1 unit(named1:2 named2:3 namedWithDefault:4)}
{Foo 1 unit(named2:2 named1:3)}
{Foo 1 unit(named1:2)} %% not ok...</
The procedure Foo is defined with pattern matching in the argument list. The ellipsis means that additional record fields are allowed. To access optional record fields, we have to explicitly try to select a field and provide a default value in case it is missing ("CondSelect").
{{omit from|Pascal}}
=={{header|Perl}}==
Perl has no non-experimental formal parameters. Instead, Perl subroutines access all of their arguments through the special array <code>@_</code>. You can easily implement named arguments by making your function interpret <code>@_</code> (or part of it) as a hash.
<
my %h = @_;
# Print every argument and its value.
Line 1,013 ⟶ 1,253:
# Otherwise, say that it's off.
print "Safe mode ", ($h{safe} ? 'on' : 'off'), ".\n";
}</
The semantics of calling such a function follow directly from the semantics of using a hash. For instance, if you provide multiple values for the same named argument, only the last one will be used. An example call:
<
verbosity => 3,
password => 'foobie blech',
Line 1,022 ⟶ 1,262:
'42' => 'answer',
password => 'joshua'
);</
Its output:
Line 1,032 ⟶ 1,272:
Safe mode off.</pre>
Further flexibility can be obtained by using [[Pass by reference]] semantics:<
{
my ($params_ref, $name) = @_;
Line 1,038 ⟶ 1,278:
my @known_params = qw(attendees event food time);
printf "%s called event() with the following named parameters:\n",
$name // 'Anonymous';
say sort map {
sprintf "%s: %s\n",
ucfirst $_,
ref $params{$_} eq ref []
? join ', ', @{ $params{$_} }
: $params{$_};
Line 1,058 ⟶ 1,298:
event(
{ # Curly braces with no label (e.g. 'sub' before it)
# create a reference to an anonymous hash
attendees => ['Bob', 'Betty', 'George', 'Bertha'],
Line 1,068 ⟶ 1,308:
},
"Joe Schmoe"
);</
<pre>
Joe Schmoe called event() with the following named parameters:
Line 1,082 ⟶ 1,322:
This is useful when you want your function to take both named (the hash) and positional (Joe Schmoe's $name) parameters.
=={{header|
{{libheader|Phix/basics}}
Phix supports named and optional parameters in a simple, natural, and intuitive way, erring on the side of caution when faced with potential ambiguity.<br>
Optional parameters are simply any with a default, and any non-defaulted parameters must occur before (to the left of) such.<br>
Named parameters can be provided in any order, but must be grouped together after (to the right of) any positional parameters.<br>
Note that low-level builtins (those defined using AutoAsm() in psym.e/syminit()) do not [yet] support named parameters, but everything else does.
The classic example (inspired by the standard Python equivalent) is that builtins\timedate.e defines:
<!--<syntaxhighlight lang="phix">-->
<span style="color: #008080;">global</span> <span style="color: #008080;">function</span> <span style="color: #000000;">timedelta</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">weeks</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">days</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">hours</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">minutes</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">seconds</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">milliseconds</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">microseconds</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
which can be invoked as follows:
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">timedate</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">days</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">hours</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">7</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">fourdays</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">timedelta</span><span style="color: #0000FF;">(</span><span style="color: #000000;">days</span><span style="color: #0000FF;">:=</span><span style="color: #000000;">4</span><span style="color: #0000FF;">),</span>
<span style="color: #000080;font-style:italic;">-- fourdays = timedelta(0,4) -- equivalent, **NB** a plain '=' is a very different thing:</span>
<span style="color: #000000;">slipup</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">timedelta</span><span style="color: #0000FF;">(</span><span style="color: #000000;">days</span><span style="color: #0000FF;">=</span><span style="color: #000000;">4</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- === timedelta([weeks:=]iff(equal(days,4)?true:false))
-- with error if no local/in scope identifier days exists.</span>
<span style="color: #000000;">shift</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">timedelta</span><span style="color: #0000FF;">(</span><span style="color: #000000;">hours</span><span style="color: #0000FF;">:=</span><span style="color: #000000;">hours</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- perfectly valid (param hours:=local hours)
-- timedelta(0,hours:=15,3) -- illegal (not clear whether days:=3 or minutes:=3)
-- though of course the weeks:=0 part is fine</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"fourdays = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fourdays</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"wrong = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">slipup</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"shift = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">shift</span><span style="color: #0000FF;">)})</span>
<!--</syntaxhighlight>-->
Note that pwa/p2js automatically maps named parameters to positional parameters for you, since JavaScript does not support named parameters.
{{out}}
<pre>
fourdays = 4 days
wrong = 0s
shift = 7 hours
</pre>
=={{header|PHP}}==
PHP doesn't support named parameters but you can simulate the behavior with PHP arrays.
<
$args += ["gbv" => 2,
"motor" => "away",
Line 1,143 ⟶ 1,370:
}
named(["teenage" => "cia", "gbv" => 10]);</
Output:
<pre>10 men running away from the cia</pre>
Line 1,152 ⟶ 1,379:
to establish bindings to passed names.
===Passing symbol-value pairs===
<
(bind (rest) # Bind symbols in CARs to values in CDRs
(println 'Bar 'is Bar)
(println 'Mumble 'is Mumble) ) )
(foo '(Bar . 123) '(Mumble . "def"))</
===Passing a name list followed by values===
<
(bind (next) # Save all symbols in first argument
(mapc set (arg) (rest)) # then bind them to remaining arguments
Line 1,165 ⟶ 1,392:
(println 'Mumble 'is Mumble) ) )
(foo '(Bar Mumble) 123 "def")</
Output in both cases:
<pre>Bar is 123
Line 1,173 ⟶ 1,400:
===Positional parameters===
When writing a function and not stating any parameters explicitly, such as the following function
<
Write-Host Argument 1 is $args[0]
}</
the only option are positional parameters using the <code>$args</code> array.
===Named parameters===
Stating any number of parameters directly in the function definition, such as
<
Write-Host "Some argument: $SomeArgument"
Write-Host "Another argument: $AnotherArgument"
Write-Host "Third argument: $ThirdArgument"
}</
will cause them to be named automatically which enables the caller to state the arguments in any order. The syntax follows the convention used with cmdlets as well:
<pre>PS> Test -ThirdArgument foo -AnotherArgument bar -SomeArgument baz
Line 1,199 ⟶ 1,426:
===Switch parameters===
Functions can have so-called ''switch parameters'' which are always boolean and either present or not. There is no need to give a value for them.
<
Write-Host Switched $(if ($on) { "on" } else { "off" })
}</
When calling a function with such a parameter the switch is simply given directly (which sets its value to ''true'') or omitted (which causes it to evaluate to ''false''):
<pre>PS> SwitchTest
Line 1,209 ⟶ 1,436:
===Optional parameters and default values===
Usually all parameters can be omitted. In the case of switch parameters this will cause them to assume the value ''false'', for normal parameters they will have the value <code>$null</code>. This is not always the desired value, though. Default values can be given too:
<
Write-Host Hello, $Name!
}</
If the <code>Name</code> argument is omitted now, its value will be <code>"Nobody"</code> instead of <code>$null</code>:
<pre>PS> Greeting
Line 1,217 ⟶ 1,444:
PS> Greeting John
Hello John!</pre>
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<syntaxhighlight lang="prolog">:- initialization(main).
main :-
sum(b=2,output=Output,a=1),
writeln(Output).
sum(A1,B1,C1) :-
named_args([A1,B1,C1],[a=A,b=B,output=Output]),
Output is A + B.
named_args([],_).
named_args([A|B],C) :-
member(A,C),
named_args(B,C).
</syntaxhighlight>
=={{header|Python}}==
Line 1,224 ⟶ 1,469:
In Python, a regular parameter of a function can be used as ''either a positional or a named'' parameter. The variable name that you use for the parameter when you declare the function becomes the "name" for the parameter, should you use it as a named parameter. When you call a function, you use the "name = value" syntax to provide the argument to a named parameter. The named arguments must come after all the positional arguments.
<
return x - y
subtract(5, 3) # used as positional parameters; evaluates to 2
subtract(y = 3, x = 5) # used as named parameters; evaluates to 2</
Parameters can be made optional by providing a default argument, as described in the [[optional parameters]] article.
Line 1,235 ⟶ 1,480:
====Function Definition Parameters====
Function definitions in Python allow for the following ''parameter'' types:
* Optional ''default parameter'' types which are explicitly specified by name, and may have an optional default value.
* An optional ''positional parameter'' which is an identifier preceded by <code>"*"</code>.
* And an optional ''keyword parameter'' which is an identifier preceded by <code>"**"</code>.
Line 1,260 ⟶ 1,505:
* All positional arguments must appear before any keyword argument.
* ''Keyword arguments'' of the form <code>parameter_name "=" value</code> will map the value to the <code>defparameter</code> in the definition of the same name.
* ''Mapping arguments'' that are the characters <code>"**"</code> followed by an expression evaluating to a mapping (such as a dict/hash). The key, value pairs from the mapping are unpacked and mapped like individual keyword arguments to <code>defparameter</code>s of the function definition.
* If the function ''definition'' includes a ''positional parameter'', then if the assignment of ''positional arguments'' and ''sequence arguments'' in the ''call'' gives more values than the <code>defparameters</code> of the definition, then these extra arguments are assembled, in order, into a tuple that is assigned to the <code>posparameter</code> of the definition.
* If the function ''definition'' includes a ''keyword parameter'', then if the parameter name of any ''keyword arguments'' and ''mapping arguments'' in the ''call'' is unknown in the <code>defparameters</code> of the function definition, then these extra keyword/value pairs are assembled into a dict that is assigned to the <code>keyparameter</code> of the definition.
* Any ''default parameter'' of the function ''definition'' that is not assigned a value at this point, but which has a default value, will be aassigned this default value, without re-evaluating the default value.
* Any ''default parameter'' of the function ''definition'' that is still un-assigned will cause a <code>TypeError</code> exception to be raised.
* In addition, multiple mappings to any parameter will raise a <code>TypeError</code> exception. (This includes multiple mappings into a <code>keyparameter</code> or keyword arguments clashing with positional/sequence arguments).
Line 1,285 ⟶ 1,530:
====Examples====
<
>>>
>>> def show_args(defparam1, defparam2 = 'default value', *posparam, **keyparam):
"Straight-forward function to show its arguments"
Line 1,309 ⟶ 1,554:
print (" <None>")
>>> show_args('POSITIONAL', 'ARGUMENTS')
Default Parameters:
Line 1,350 ⟶ 1,595:
Keyword Arguments (by sorted key name):
<None>
>>> show_args('POSITIONAL', 'ARGUMENTS',
'EXTRA', 'POSITIONAL', 'ARGUMENTS')
Default Parameters:
Line 1,361 ⟶ 1,606:
Keyword Arguments (by sorted key name):
<None>
>>> show_args('POSITIONAL', 'ARGUMENTS',
kwa1='EXTRA', kwa2='KEYWORD', kwa3='ARGUMENTS')
Default Parameters:
Line 1,372 ⟶ 1,617:
keyword argument: kwa2 is: KEYWORD
keyword argument: kwa3 is: ARGUMENTS
>>> show_args('POSITIONAL',
'ARGUMENTS', 'EXTRA', 'POSITIONAL', 'ARGUMENTS',
kwa1='EXTRA', kwa2='KEYWORD', kwa3='ARGUMENTS')
Default Parameters:
Line 1,387 ⟶ 1,632:
keyword argument: kwa3 is: ARGUMENTS
>>> # But note:
>>> show_args('POSITIONAL', 'ARGUMENTS',
kwa1='EXTRA', kwa2='KEYWORD', kwa3='ARGUMENTS',
'EXTRA', 'POSITIONAL', 'ARGUMENTS')
SyntaxError: non-keyword arg after keyword arg
>>></
=={{header|R}}==
Line 1,414 ⟶ 1,642:
R parameters are all named; arguments can be passed either positionally or with explicit naming. The named arguments are matched to their parameters first, then the unnamed arguments fill in remaining slots. A parameter whose name begins with a period will not be matched to unnamed arguments. R allows abbreviated names to be used as long as they match uniquely to an argument.
<
numerator / denominator
}
Line 1,423 ⟶ 1,651:
divide(den=3, num=2) # 0.66
divide(den=3, 2) # 0.66
divide(3, num=2) # 0.66</
=={{header|Racket}}==
Line 1,429 ⟶ 1,657:
Racket has built-in keyword and optional arguments:
<
#lang racket
(define (pizza sauce
;; mandatory keyword argument
#:topping topping
;; optional keyword argument with default
#:type [type "deep dish"])
Line 1,442 ⟶ 1,670:
(pizza "tomato" #:topping "onion")
(pizza #:topping "onion" "garlic" #:type "pan")
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|#22 "Thousand Oaks"}}
Raku's support for optional parameters is much like Python's. Consider this declaration:
<syntaxhighlight lang="raku" line>sub funkshun ($a, $b?, $c = 15, :$d, *@e, *%f) {
...
}</syntaxhighlight>
In the above signature:
* <code>$a</code> is a mandatory parameter accepted by position (<code>funkshun 15, ...</code>).
* <code>$b</code> is an optional parameter that can be passed by position or by name. By default, it's undefined.
* <code>$c</code> is an optional parameter that can be passed by position or by name. Its default value is <code>15</code>.
* <code>$d</code> is an optional parameter that can only be passed by name. By default, it's undefined.
* <code>@e</code> is a slurpy array: it receives any leftover positional arguments.
* <code>%f</code> is a slurpy hash: it receives any leftover named arguments.
So, if we defined the function like this:
<syntaxhighlight lang="raku" line>sub funkshun ($a, $b?, :$c = 15, :$d, *@e, *%f) {
say "$a $b $c $d";
say join ' ', @e;
say join ' ', keys %f;
}
# this particularly thorny call:
funkshun
'Alfa', k1 => 'v1', c => 'Charlie', 'Bravo', 'e1',
d => 'Delta', 'e2', k2 => 'v2';</syntaxhighlight>
would print this:
<pre>Alfa Bravo Charlie Delta
e1 e2
k1 k2</pre>
=={{header|REXX}}==
===version 1===
<
/*┌────────────────────────────────────────────────────────────────────┐
│ The syntax of: xxx = func1(parmName2=arg2, parmName1=arg1) │
Line 1,521 ⟶ 1,787:
return 'the final meaning of life, or 42 --- whichever is appropriate.'
/*stick a fork in it, we're done.*/</
===version 2===
<
* 01.07.2014 Walter Pachl
* Argument values must not start with 'arg'
Line 1,543 ⟶ 1,809:
Say 'p.'i'='p.i
End
Return p.1**p.2</
{{Out}}
<pre>p.1=2
Line 1,558 ⟶ 1,824:
{{trans|Tcl}}
{{works with|Ruby|2.0}}
<
puts "foo is #{foo}, bar is #{bar}, and grill is #{grill}"
end
# Note that :foo is omitted and :grill precedes :bar
example(grill: "lamb kebab", bar: 3.14)</
Ruby 1.9 can fake the effect with a Hash. If a caller passes <code>name: value</code> pairs, Ruby makes a Hash, and the called method sees this Hash in its last argument. To complete the effect, the method may declare an optional last argument that defaults to an empty Hash <code>{}</code>. In this version, <code>example(typo: 4)</code> causes no error.
Line 1,569 ⟶ 1,835:
{{works with|Ruby|1.9}}
<
# Hash#merge raises TypeError if _opts_ is not a Hash.
# Nothing checks if _opts_ contains unknown keys.
Line 1,579 ⟶ 1,845:
end
example(grill: "lamb kebab", bar: 3.14)</
{{omit from|Rust}}
=={{header|Scala}}==
Line 1,596 ⟶ 1,853:
Scala 2.8 utilizes named parameters and default values:
<
def add(x: Int, y: Int = 1) = x + y
</syntaxhighlight>
<
scala> add(5)
6
Line 1,606 ⟶ 1,863:
scala> add(y=10, x=4)
14
</syntaxhighlight>
=={{header|Scheme}}==
<
(define (keyarg-parser argdefs args kont)
(apply kont
Line 1,631 ⟶ 1,888:
(display first)))
(newline))))
</syntaxhighlight>
<
=> (print-name)
?
Line 1,642 ⟶ 1,899:
=>(print-name 'last "Doe")
Doe
</syntaxhighlight>
=={{header|SenseTalk}}==
The <b>introduce</b> handler here includes a default value for <b>greeting</b>. Ordinarily, parameters are passed sequentially, but <code>by name</code> can be used to match values from a property list to the corresponding parameters of the handler that is being called.<syntaxhighlight lang="sensetalk">introduce "Mary"
introduce "Pablo", "Hola"
introduce greeting:"Bonjour", name:"Brigitte" by name
to introduce name, greeting:"Hello"
put greeting && name
end introduce
</syntaxhighlight>
{{out}}
<pre>
Hello Mary
Hola Pablo
Bonjour Brigitte
</pre>
=={{header|Sidef}}==
<
say "foo is #{foo}, bar is #{bar}, and grill is #{grill}";
}
# Note that :foo is omitted and :grill precedes :bar
example(grill: "lamb kebab", bar: 3.14);</
{{out}}
<pre>foo is 0, bar is 3.14, and grill is lamb kebab</pre>
Line 1,660 ⟶ 1,933:
{{works with|GNU Smalltalk}}
<
"..."
initWithArray: anArray [ "single argument" ]
initWithArray: anArray andString: aString [
"two args; these two methods in usage resemble
a named argument, with optional andString argument"
]
"..."
]</
=={{header|Standard ML}}==
This example uses Standard ML "fields".
<
fun example {a, b, c} = dosomething (a, b, c)</
To call the procedure ''example'', use:
<
However, this does not support optional parameters. To emulate them, we can process a parameter list:
<
fun args xs =
Line 1,690 ⟶ 1,963:
map (fn (A x) => a := x | (B x) => b := x | (C x) => c := x) xs;
(!a, !b, !c)
end</
To process the argument list and call ''example'', use:
<
=={{header|Suneido}}==
Suneido can handle named and unnamed parameters. When using a combination, unnamed parameters must come before named ones and must be in the correct order. Named parameters can be in any order. Named parameters are given a default value so they are not mandatory.
<syntaxhighlight lang="suneido">
test = function (one, two, three = '', four = '', five = '')
{
Print('one: ' $ one $ ', two: ' $ two $ ', three: ' $ three $
', four: ' $ four $ ', five: ' $ five)
}
test('1', '2', five: '5', three: '3')
</syntaxhighlight>
Output:
<
=={{header|Swift}}==
Each function parameter has both an argument label and a parameter name. The argument label is used when calling the function; each argument is written in the function call with its argument label before it. The parameter name is used in the implementation of the function. By default, parameters use their parameter name as their argument label.
<
return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", hometown: "Cupertino"))</
You write an argument label before the parameter name, separated by a space:
<
return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))</
If you don’t want an argument label for a parameter, write an underscore (_) instead of an explicit argument label for that parameter.
If a parameter has an argument label, the argument must be labeled when you call the function.
<
return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet("Bill", "Cupertino"))</
You can define a default value for any parameter in a function by assigning a value to the parameter after that parameter’s type. If a default value is defined, you can omit that parameter when calling the function.
<
return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet(person: "Bill"))</
=={{header|Tcl}}==
===Using arrays===
The simplest way of passing named parameters is to use the Tcl language's strong support for [[Varargs#Tcl|variadic commands]] together with its arrays. By convention (originally from [[Tk]]) the named parameters names start with a hyphen (“<tt>-</tt>”) and are called options.
<
# Set the defaults
array set opts {-foo 0 -bar 1 -grill "hamburger"}
Line 1,744 ⟶ 2,019:
# Note that -foo is omitted and -grill precedes -bar
example -grill "lamb kebab" -bar 3.14
# => ‘foo is 0, bar is 3.14, and grill is lamb kebab’</
More complex option parsing is possible, e.g., with the <tt>opt</tt> package (of which only a small fraction of the functionality is shown here). This package also allows you to specify type constraints, though that is usually not necessary, and will generate a standard help message that can be obtained with the <tt>-help</tt> option:
<
tcl::OptProc example {
{-foo -int 0 "The number of foos"}
Line 1,763 ⟶ 2,038:
# -foo int (0) The number of foos
# -bar float (1.0) How much bar-ness
# -grill any (hamburger) What to cook on the grill</
According to [http://wiki.tcl.tk/1730 wiki.tcl.tk discussions], '''::tcl::OptProc is deprecated.'''
The recommended replacement is [http://tcllib.sourceforge.net/doc/cmdline.html cmdline] in [http://tcllib.sourceforge.net/doc/index.html tcllib]. "This is probably the most standard and widely-used of these packages."
===Using dicts===
Now (8.5) that dicts are here to replace arrays in most places, this can be achieved more cleanly as long as you do the authorized key checking yourself. Example of summary testing (to put in a nice uplevel wrapper):
<syntaxhighlight lang="tcl">proc example {x y args} {
set keyargs {arg1 default1 arg2 default2}
if {[llength $args] % 2 != 0} {
error "$args: invalid keyword arguments (spec: $keyargs)"
}
set margs [dict merge $keyargs $args]
if {[dict size $margs] != [dict size $keyargs]} {
error "$args: invalid keyword arguments (spec: $keyargs)"
}
lassign [dict values $margs] {*}[dict keys $margs]
puts "x: $x, y: $y, arg1: $arg1, arg2: $arg2"
}
example 1 2 # => x: 1, y: 2, arg1: default1, arg2: default2
example 1 2 arg2 3 # => x: 1, y: 2, arg1: default1, arg2: 3
example 1 2 test 3 # => test 3: invalid keyword arguments (spec: arg1 default1 arg2 default2)
example 1 2 test # => test: invalid keyword arguments (spec: arg1 default1 arg2 default2)</syntaxhighlight>
Of course, more work is required to reach the flexibility of something like Common Lisp's ordinary lambda list.
=={{header|VBA}}==
{{trans|Phix}}<
Public Function timedelta(Optional weeks As Integer = 0, Optional days As Integer = 0, _
Optional hours As Integer = 0, Optional minutes As Integer = 0, Optional seconds As Integer = 0, _
Line 1,786 ⟶ 2,083:
'-- timedelta(0,hours:=15,3) '-- illegal (it is not clear whether you meant days:=3 or minutes:=3)
'VBA expects a named parameter for 3
End Sub</
=={{header|Visual Basic}}==
<
Sub whatever(foo As Long, bar As Integer, baz As Byte, qux As String)
'...
Line 1,795 ⟶ 2,093:
Sub crap()
whatever bar:=1, baz:=2, foo:=-1, qux:="Why is ev'rybody always pickin' on me?"
End Sub</
=={{header|V (Vlang)}}==
1) Vlang allows for a struct literal to be passed to the function, instead of named parameters.
2) Using this style, fields need not appear in the same order as they are declared.
3) If one or more fields are omitted, their default values will be used instead.
4) The named parameter feature was deliberately omitted, for greater code readability.
5) Depending on the situation, variadic and/or sum types can also be considered.
<syntaxhighlight lang="Zig">
struct Params {
a int
b int
c int
}
fn a_fn(p Params) int {
return p.a + p.b + p.c
}
fn main() {
x := a_fn(Params{a: 1, b: 2, c: 3}) // same order
println("x = ${x}")
y := a_fn(Params{c: 3, b: 2, a: 1}) // different order
println("y = ${y}")
z := a_fn(Params{c: 2}) // only one field
println("z = ${z}")
}
</syntaxhighlight>
{{out}}
<pre>
x = 6
y = 6
z = 2
</pre>
=={{header|Wren}}==
Wren doesn't support named parameters as such though they can be simulated using a map.
<syntaxhighlight lang="wren">var printName = Fn.new { |name|
if (!(name is Map && name["first"] != null && name["last"] != null)) {
Fiber.abort("Argument must be a map with keys \"first\" and \"last\"")
}
System.print("%(name["first"]) %(name["last"])")
}
printName.call({"first": "Abraham", "last": "Lincoln"}) // normal order
printName.call({"last": "Trump", "first": "Donald"}) // reverse order
printName.call({"forename": "Boris", "lastname": "Johnson"}) // wrong parameter names</syntaxhighlight>
{{out}}
<pre>
Abraham Lincoln
Donald Trump
Argument must be a map with keys "first" and "last"
[./named_params line 3] in new(_) block argument
[./named_params line 10] in (script)
</pre>
=={{header|XSLT}}==
XSLT only allows specification of template parameters by name, not position.
<
<xsl:param name="title"/>
...
</xsl:template></
{{omit from|6502 Assembly|does not support named arguments without macros, which are entirely position-based}}
{{omit from|68000 Assembly|See above.}}
{{omit from|8086 Assembly|See above.}}
{{omit from|Axe}}
{{omit from|BASIC}}
Line 1,809 ⟶ 2,170:
{{omit from|bc}}
{{omit from|dc}}
{{omit from|GUISS}}
{{omit from|Joy}}
Line 1,817 ⟶ 2,177:
{{omit from|TI-89 BASIC}}
{{omit from|UNIX Shell}}
{{omit from|Z80 Assembly}}
{{omit from|zkl}}
{{omit from|ZX Spectrum Basic}}
|