Editing Named parameter

{{Short description|Concept in computer programming}}
{{more citations needed|date=August 2014}}

In [[computer programming]], '''named parameters''', '''named-parameter arguments''', '''named arguments''' or '''keyword arguments''' refer to a computer language's support for function calls to clearly associate each [[Parameter_(computer_programming)|argument]] with a given [[Parameter (computer science)|parameter]] within the function call.

== Overview ==
A function call using named parameters differs from a regular function call in that the arguments are passed by associating each one with a parameter name, instead of providing an ordered list of arguments.

For example, consider this [[Java (programming language)|Java]] or [[C Sharp (programming language)|C#]] method call that doesn't use named parameters:

<syntaxhighlight lang="java">
window.addNewControl("Title", 20, 50, 100, 50, true);
</syntaxhighlight>

Using named parameters in [[Python (programming language)|Python]], the call can be written as:
<syntaxhighlight lang="python">
window.addNewControl(title="Title",
                     xPosition=20,
                     yPosition=50,
                     width=100,
                     height=50,
                     drawingNow=True)
</syntaxhighlight>
Using named parameters in [[PHP]], the call can be written as:
<syntaxhighlight lang="php">
$window->addNewControl(title: "Title",
                       xPosition: 20,
                       yPosition: 50,
                       width: 100,
                       height: 50,
                       drawingNow: True);
</syntaxhighlight>
The version with positional arguments is more implicit. The versions that name parameters are more explicit. Depending on circumstance, a programmer may find one or the other to be easier to read.

== Use in programming languages ==
Named parameters are supported explicitly in many languages. A non-exhaustive selection of examples includes [[Ada (programming language)|Ada]],<ref>{{cite book|author=|year=1983|title=Reference Manual for the Ada Programming Language|publisher=United States Department of Defense|isbn=}}</ref> [[C Sharp 4.0|C# 4.0+]],<ref>{{Cite web|last=BillWagner|title=Named and Optional Arguments - C# Programming Guide|url=https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments|access-date=2021-06-16|website=Microsoft Learn|language=en-us}}</ref> [[Ceylon (programming language)|Ceylon]]{{Citation needed|date=July 2021}}, [[ColdFusion Markup Language]] (CFML){{Citation needed|date=July 2021}}, [[Common Lisp]],<ref>{{Cite web|title=Functions|url=https://lispcookbook.github.io/cl-cookbook/functions.html|access-date=2021-10-28|website=The Common Lisp Cookbook }}</ref> [[Fortran]]{{Citation needed|date=July 2021}}, [[IDL (programming language)|IDL]]{{Citation needed|date=July 2021}}, [[Kotlin (programming language)|Kotlin]],<ref>{{Cite web|title=Functions {{!}} Kotlin|url=https://www.jetbrains.com/idea/functions.html|access-date=2021-06-16|website=Kotlin Help|language=en-US}}{{dead link|date=December 2023}}</ref> [[Mathematica]]{{Citation needed|date=July 2021}}, [[PL/SQL]]{{Citation needed|date=July 2021}}, [[PowerShell]]{{Citation needed|date=July 2021}}, [[Python (programming language)|Python]],<ref>{{Cite web|title=8. Compound statements - 8.7. Function definitions |url=https://docs.python.org/3/reference/compound_stmts.html#function-definitions|access-date=2021-10-28|website=Python documentation }}</ref> [[R (programming language)|R]],<ref>{{Cite web|title=10.3 Named arguments and defaults|url=https://cran.r-project.org/doc/manuals/r-release/R-intro.html#Named-arguments-and-defaults |publisher=The Comprehensive R Archive Network |access-date=2021-10-28|website=An Introduction to R}}</ref> [[PHP]],<ref>{{Cite web|title=PHP: Function arguments - Manual - Named Arguments |url=https://www.php.net/manual/en/functions.arguments.php#functions.named-arguments|access-date=2021-06-16|website=PHP }}</ref> [[Ruby (programming language)|Ruby]],<ref>{{Cite web|title=Ruby 2 Keyword Arguments|url=https://thoughtbot.com/blog/ruby-2-keyword-arguments |first1=Ian C. |last1=Anderson |access-date=2021-10-28|website=thoughtbot |date=21 July 2014}}</ref> [[Scala (programming language)|Scala]],<ref>{{Cite web|title=Named Arguments|url=https://docs.scala-lang.org/tour/named-arguments.html|access-date=2021-06-16|website=Scala Documentation}}</ref> [[Smalltalk]]{{Citation needed|date=July 2021}}, [[Swift (programming language)|Swift]]<ref>{{Cite web|url=https://docs.swift.org/swift-book/LanguageGuide/Functions.html#ID166|title=Functions |website=The Swift Programming Language (Swift 5.1) |access-date=2020-01-27}}</ref> and [[Visual Basic]].<ref>{{Cite web|last=KathleenDollard|title=Passing Arguments by Position and by Name - Visual Basic|url=https://docs.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/procedures/passing-arguments-by-position-and-by-name|access-date=2021-06-16|website=Microsoft Learn|language=en-us}}</ref> [[Objective-C]] does not have named parameters (even though parts of the method name may look like named parameters).<ref>''[https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/DefiningClasses/DefiningClasses.html#//apple_ref/doc/uid/TP40011210-CH3-SW5|iOS Developer Library - The Implementation of a Class Provides Its Internal Behavior]''</ref>
<br>In [[C++]], you can achieve named parameters by using designated initializers since [[C++20]],<ref>{{Cite web|url=https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf|title=Designated Initialization Wording}}</ref> like so:
<syntaxhighlight lang="cpp">
struct A {int a{}, int b{} }; 

void
foo(A bar)
{
   std::cout << bar.a << bar.b;
}
foo({ .a = 1, .b = 3 });
</syntaxhighlight>

== Order of parameters ==
In languages that do not support named parameters, the ''order'' of arguments in a function call is necessarily fixed, since it is the only way that the language can identify which argument is intended to be used for which parameter.

With named parameters, it is usually possible to provide the arguments in any order, since the parameter name attached to each argument identifies its purpose. This reduces the [[connascence]] between parts of the program. A few languages support named parameters but still require the arguments to be provided in a specific order.

== Optional parameters and positional parameters{{anchor|Optional_parameters}}==
{{Main article|Default argument}}
Named parameters are often used in conjunction with optional parameters.  Without named parameters, optional parameters can only appear at the end of the parameter list, since there is no other way to determine which values have been omitted.  In languages that support named optional parameters, however, programs may supply any subset of the available parameters, and the names are used to determine which values have been provided.

An added complication arises in languages such as [[OCaml]] that support both optional named parameters and [[partial application]]. It is impossible in general to distinguish between a function partly applied, and a function to which a subset of parameters have been provided.  OCaml resolves this ambiguity by requiring a positional argument after all optional named-parameter arguments: its presence or absence is used to decide if the function has been fully or partly applied. If all parameters are optional, the implementor may solve the issue by adding a dummy positional parameter of type [[Unit type|unit]].

== Emulating ==
In languages that do not support named parameters, some of the same benefits can be achieved in other ways.

=== With documentation ===
Their value as documentation can be replicated by tooltips in [[integrated development environment]]s (IDEs) for languages such as [[Java (programming language)|Java]], or with comments (in [[C (programming language)|C]]):
<syntaxhighlight lang="c">
MyFunctionCall(
    20,  /* x coordinate */
    50,  /* y coordinate */
    100, /* width */
    5,   /* height */
    TRUE /* drawing now? */
); 
</syntaxhighlight>

Such comments are not checked for correctness and the order of arguments remains important.

=== With data structures ===
Removing the argument order restriction, and the ability to leave some values unspecified, can be achieved by passing a [[record (computer science)|record]] or [[associative array]].

For example, in [[JavaScript]], these two calls are equivalent:
<syntaxhighlight lang="JavaScript">
MyFunctionCall({ xPosition: 20, yPosition: 50, width: 100, height: 5,
                 drawingNow: true });
</syntaxhighlight>
<syntaxhighlight lang="JavaScript">
MyFunctionCall({ width: 100, height: 5, xPosition: 20, yPosition: 50,
                 drawingNow: true });
</syntaxhighlight>

Compare to C99:<ref>{{Cite web|url=https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html|title = Designated Inits (Using the GNU Compiler Collection (GCC))}}</ref>
<syntaxhighlight lang="c">
struct MyParam {
    int xPosition;
    int yPosition;
    int width;
    int height;
    unsigned char drawingNow;
};
…
MyParam parameters = { .xPosition = 20, .yPosition = 50,
        .width = 100, .height = 5, .drawingNow  = TRUE };
MyFunctionCall(&parameters);
</syntaxhighlight>

==== Special Support ====

In [[Perl]] and pre-2.0 [[Ruby (programming language)|Ruby]] a similar convention exists (generally called a ''hash'' or ''options hash''<ref>[https://docstore.mik.ua/orelly/perl/prog3/ch02_09.htm Programming Perl 2.9: Hashes]</ref>), with special support for omitting the delimiters within function calls. As an example, the core module's Net::FTP ''new'' function accepts a hash of optional arguments.<ref>[http://perldoc.perl.org/Net/FTP.html Perl core module Net::FTP]</ref>

=== With chained method calls ===
In [[object-oriented programming]] languages, it is possible to use [[method chaining]] to simulate named parameters, as a form of [[fluent interface]]. Each named-parameter argument is replaced with a method on an "arguments" object that modifies and then returns the object. In C++, this is termed the ''named parameter idiom''.<ref>C++ FAQ, [http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.20 10.20 What is the "Named Parameter Idiom"?]</ref> The object may then be passed to a function that uses the arguments it contains.

[[Method chaining]] is often used in conjunction with the [[builder pattern]] as a way to override default values provided by the builder class.

==See also==

* [[Help:Template#Handling parameters|Help:Template]] for named and positional parameters.
* [[Fluent interface]]
* [[Tag (programming)]]

==References==
{{Reflist}}

==External links==
* https://web.archive.org/web/20070502112455/http://plg.uwaterloo.ca/~rgesteve/cforall/named_pars.html
* In C++ this paradigm can be easily implemented: [http://www.boost.org/doc/libs/1_53_0/libs/parameter/doc/html/ Boost Parameter Library]
* [http://rosettacode.org/wiki/Named_parameters Named Parameters in various programming languages] at [[Rosetta Code]]

[[Category:Subroutines]]
[[Category:Articles with example C code]]
[[Category:Articles with example JavaScript code]]
[[Category:Articles with example PHP code]]
[[Category:Articles with example Python (programming language) code]]