Named parameter

In computer programming, named parameters, pass-by-name, or keyword arguments refer to a computer language's support for function calls that clearly state the name of each parameter within the function call itself.

Overview

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

For example, consider the following Java method call that does not use named parameters:

window.addNewControl("Title", 20, 50, 100, 50, true);

Using named parameters in Objective-C, the call can be written as:

[window addNewControlWithTitle:@"Title"
                     xPosition:20
                     yPosition:50
                         width:100
                        height:50
                    drawingNow:YES];

The Objective-C version is more explicit, while the Java version is more concise. Depending on the particular instance, a programmer may find one or the other easier to read.

Use in programming languages

Named parameters are explicitly supported in many languages: a non-exhaustive selection of examples would include Ada, C# 4.0+, Coldfusion, Common Lisp, Scala, Mathematica, PL/SQL, Python, R, Smalltalk, Visual Basic, IDL, Swift and Objective C.

Order of parameters

In languages without named parameters, the order of parameters is necessarily fixed, since it is the only thing that the language can use to identify which value is intended to be used for which purpose.

With named parameters, it is usually possible to provide the values in any arbitrary order, since the name attached to each value identifies its purpose. A few languages such as Objective-C use names but require the parameters to be provided in a specific order.

Optional parameters

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, the programmer may supply any subset of the available parameters, and the names are used to determine which values have been provided.

An additional 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 partially applied function and a function to which a subset of parameters have been provided. OCaml resolves this ambiguity by requiring a positional parameter to follow all optional named parameters: its presence or absence is used to decide whether the function has been fully or partially applied. If all parameters are optional, the implementor may solve the issue by adding a dummy positional parameter of type unit.

Emulating

In languages without 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 IDEs for languages such as Java, or with comments (in C):

MyFunctionCall(
    20,  /* x coordinate */
    50,  /* y coordinate */
    100, /* width */
    5,   /* height */
    TRUE /* drawing now? */
);

But this does not provide any checking, and the order of arguments remains important.

With data structures

The removal of the argument order restriction, and the ability to leave some values unspecified, can be achieved by passing a record or associative array.

For example, in JavaScript, the following two calls are equivalent:

MyFunctionCall({ xPosition: 20, yPosition: 50, width: 100, height: 5,
                 drawingNow: true });

MyFunctionCall({ width: 100, height: 5, xPosition: 20, yPosition: 50,
                 drawingNow: true });

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

With chained method calls

In object-oriented languages, it is possible to use method chaining to simulate named parameters, as a form of fluent interface. Each named parameter is replaced with a method on a parameter object that modifies and then returns the object. In C++, this is known as the Named Parameter Idiom. The object may then be passed to a function that uses the parameters it contains. When this approach is extended to handle optional named parameters with default values, it is known as the Builder pattern.

See also

• Tag

External links

• http://web.archive.org/web/20070502112455/http://plg.uwaterloo.ca/~rgesteve/cforall/named_pars.html
• In C++ this paradigm can be easily implemented: Boost Parameter Library
• Named Parameters in various programming languages at Rosetta Code