Named parameters: Difference between revisions

* [[Optional parameters]]

* [[wp:Named parameter|Wikipedia: Named parameter]]

 

=={{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);

 

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

{{trans|Lua}}

 

 

 

 

Output:

<pre>

</pre>

=={{header|AppleScript}}==

AppleScript does not implement default or optional parameters, but they can be simulated using records.

set {firstName, lastName} to {"?", "?"}

try

set lastName to x's lastName

end try

Examples:

--> Returns: "John, Doe"

getName({lastName:"Doe"})

 

=={{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$ = ""

 

<pre>]FIRST$ = "JOHN" : GOSUB 100"PRINT NAME

]FIRST$ = "JOHN" : LAST$ = "DOE" : GOSUB 100"PRINT NAME

DOE, JOHN</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"

& testproc$((z,4) (x,2) (y,3)) { order is not important }

& testproc$((i,1) (y,2) (z,3))

Output:

<pre>Calling testproc

{{works with|C99}}

 

 

// 1. Named parameters

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++}}==

You wrap the parameters in a class, and make the function a friend of the parameter class.

 

friend void foo(foo_params p);

public:

int required_param_;

int optional_x_;

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

 

#include <boost/parameter/preprocessor.hpp>

#include <string>

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.

(bar, (float))

)

(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);

 

=={{header|Clojure}}==

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]

 

Clojure 1.2 supports destructuring of trailing arguments as a map:

 

 

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]

 

Sample output for all variants:

=={{header|Common Lisp}}==

 

(princ last)

(when first

(princ ", ")

(princ first))

 

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

Doe, John

CL-USER> (print-name :last "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|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.

 

if (last == null) {

print("?")

print(first)

}

 

(Note: In map literals and map patterns, “<code>=> <var>x</var></code>” is shorthand for “<code>"<var>x</var>" => <var>x</var></code>”.)

 

?, John

 

 

? printName(["first" => "John", "last" => "Doe"])

 

=={{header|Fortran}}==

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

! ...

 

integer :: r

call a_sub(1,2, r)

 

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

!...

 

call b_sub(arg2=1) ! ok

call b_sub(1, 2) ! ok: arg1 is 1, arg2 is 2

 

=={{header|Haskell}}==

We can simulate named, but not moveable arguments, with nullary data constructors:

 

data Y = Y

data Point = Point Int Int deriving Show

createPointAt X x Y y = Point x y

 

 

We can also emulate named, moveable, optional arguments with record syntax:

 

defaultPoint = Point {x = 0, y = 0}

 

createPointAt :: Point -> Point

createPointAt = id

 

Though this is cumbersome without using template Haskell, as the call site must supply the defaults.

 

 

testproc("x:=",1,"y:=",2,"z:=",3)

testproc("x:=",3,"y:=",1,"z:=",2)

((variable(a[1:-2]) := get(A)) | # assign

runerr(205,a))) # . . problem

write(" x:=",x)

write(" y:=",y)

write(" z:=",z)

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

 

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]

NB. Order of names is flexible

myFunc[COLOR=blue, MAX=906 fs]

NB. Even the delimiters are flexible...

 

For further discussion, see the [http://www.jsoftware.com/pipermail/programming/2009-July/015571.html corresponding thread in the J Forums].

=={{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 = {}

 

example({grill: "lamb kebab", bar: 3.14});

 

=={{header|Julia}}==

Julia supports arbitrary named keyword arguments, which are listed (with their default values) after a <code>;</code> in the function definition:

 

 

println(ul, ho^(length(string) + 2padding), ur, "\n",

ve, " "^padding, string," "^padding, ve, "\n",

dl, ho^(length(string) + 2padding), dr)

 

{{Out}}

╚═══════╝</pre>

 

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.

 

 

=={{header|Lasso}}==

-first::integer, // with no default value the param is required

-second::integer,

-first = 54,

-delimiter = '#'

-> 54:45

 

54#45

 

=={{header|Lua}}==

function CreatePet(options)

local name=options.name

CreatePet{name='Rex',species='Dog',breed='Irish Setter'}

--position does not matter here.

 

 

fn[3,4,{Add->True,Offset->2}]

 

=={{header|MATLAB}} / {{header|Octave}}==

Named parameters are not natively supported. However, the following code can be used to implement them.

 

for k= 1:2:length(varargin);

switch (varargin{k})

case {'param2'}

param2 = varargin{k+1};

 

param1: a1

param2: b2

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

 

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

 

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

}

- (double) hypotenuseOfX: (double)x andY: (double)y andZ: (double)z;

 

 

- (double) hypotenuseOfX: (double)x andY: (double)y {

}

 

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

 

Named arguments can be re-ordered, but two arguments of the same label cannot be re-ordered relative to each other.

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

{O bar(1 named1:2 named2:3 namedWithDefault:4)} %% ok

{O bar(1 named2:2 named1:3)} %% ok

 

For <b>procedures</b> only positional parameters are supported. However, you can emulate named parameters by using records:

declare

proc {Foo PP Other=unit(named1:N1 named2:N2 ...)}

{Foo 1 unit(named1:2 named2:3 namedWithDefault:4)}

{Foo 1 unit(named2:2 named1:3)}

 

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

 

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

 

print qq(Argument "$_" has value "$h{$_}".\n)

foreach sort keys %h;

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:

 

Its output:

 

Safe mode off.</pre>

 

 

 

 

}

 

 

 

 

 

 

 

 

 

 

=={{header|PicoLisp}}==

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

 

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

(println 'Mumble 'is Mumble) ) )

 

Output in both cases:

<pre>Bar is 123

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

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

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

PS> Greeting John

Hello John!</pre>

 

=={{header|Python}}==

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

 

Parameters can be made optional by providing a default argument, as described in the [[optional parameters]] article.

====Function Definition Parameters====

Function definitions in Python allow for the following ''parameter'' types:

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

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

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

 

====Examples====

>>> def show_args(defparam1, defparam2 = 'default value', *posparam, **keyparam):

"Straight-forward function to show its arguments"

print (" <None>")

 

>>> show_args('POSITIONAL', 'ARGUMENTS')

Default Parameters:

Keyword Arguments (by sorted key name):

<None>

'EXTRA', 'POSITIONAL', 'ARGUMENTS')

Default Parameters:

Keyword Arguments (by sorted key name):

<None>

kwa1='EXTRA', kwa2='KEYWORD', kwa3='ARGUMENTS')

Default Parameters:

keyword argument: kwa2 is: KEYWORD

keyword argument: kwa3 is: ARGUMENTS

kwa1='EXTRA', kwa2='KEYWORD', kwa3='ARGUMENTS')

Default Parameters:

keyword argument: kwa3 is: ARGUMENTS

>>> # But note:

'EXTRA', 'POSITIONAL', 'ARGUMENTS')

SyntaxError: non-keyword arg after keyword arg

 

=={{header|R}}==

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

}

divide(den=3, num=2) # 0.66

divide(den=3, 2) # 0.66

 

=={{header|Racket}}==

Racket has built-in keyword and optional arguments:

 

#lang racket

 

(define (pizza sauce

;; mandatory keyword argument

;; optional keyword argument with default

#:type [type "deep dish"])

(pizza "tomato" #:topping "onion")

(pizza #:topping "onion" "garlic" #:type "pan")

 

=={{header|REXX}}==

/*┌────────────────────────────────────────────────────────────────────┐

│ The syntax of: xxx = func1(parmName2=arg2, parmName1=arg1) │

 

return 'the final meaning of life, or 42 --- whichever is appropriate.'

 

=={{header|Ruby}}==

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

 

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.

{{works with|Ruby|1.9}}

 

# Hash#merge raises TypeError if _opts_ is not a Hash.

# Nothing checks if _opts_ contains unknown keys.

end

 

 

 

=={{header|Scala}}==

Scala 2.8 utilizes named parameters and default values:

 

def add(x: Int, y: Int = 1) = x + y

 

scala> add(5)

6

scala> add(y=10, x=4)

14

 

=={{header|Scheme}}==

(define (keyarg-parser argdefs args kont)

(apply kont

(display first)))

(newline))))

 

=> (print-name)

?

=>(print-name 'last "Doe")

Doe

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

 

"..."

initWithArray: anArray [ "single argument" ]

"two args; these two methods in usage resemble

a named argument, with optional andString argument"

]

"..."

 

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

test = function (one, two, three = '', four = '', five = '')

{

', four: ' $ four $ ', five: ' $ five)

}

test('1', '2', five: '5', three: '3')

Output:

 

=={{header|Tcl}}==

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

# Note that -foo is omitted and -grill precedes -bar

example -grill "lamb kebab" -bar 3.14

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

# -foo int (0) The number of foos

# -bar float (1.0) How much bar-ness

 

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

 

=={{header|Visual Basic}}==

Sub whatever(foo As Long, bar As Integer, baz As Byte, qux As String)

'...

Sub crap()

whatever bar:=1, baz:=2, foo:=-1, qux:="Why is ev'rybody always pickin' on me?"

 

=={{header|XSLT}}==

XSLT only allows specification of template parameters by name, not position.

<xsl:param name="title"/>

...

{{omit from|BASIC}}

{{omit from|BBC BASIC}}

{{omit from|bc}}

{{omit from|dc}}

{{omit from|GUISS}}

{{omit from|Joy}}

{{omit from|TI-89 BASIC}}

{{omit from|UNIX Shell}}

{{omit from|zkl}}

{{omit from|ZX Spectrum Basic}}