DOKUMEN123.COM

Function `concat_and_call` (code)
Num. of arguments	Ad libitum
Not affected by	all_sorted, reassorted
See also
	combining, combining_values, combining_by_calling, combining_by_invoking, combining_by_magic, concat_and_invoke, concat_and_magic, {{#invoke:template wrapper\|wrap}}

Function `count` (code)
Num. of arguments	0
Often preceeded by	sequential
Not affected by	all_sorted, reassorted, setting,; sorting_sequential_val…,; mapping_by_calling, mapping_by_invoking, mapping_by_magic, mapping_by_replacing
See also
	{{#invoke:ParameterCount}}

Function `self` (code)
Num. of arguments	0
Not affected by	Any modifier
See also
	{{#invoke:TEMPLATENAME\|main}}, {{FULLPAGENAME}}

Module documentation[view] [edit] [history] [purge]

This module is rated as ready for general use. It has reached a mature state, is considered relatively stable and bug-free, and may be used wherever appropriate. It can be mentioned on help pages and other Wikipedia resources as an option for new users. To minimise server load and avoid disruptive output, improvements should be developed through sandbox testing rather than repeated trial-and-error editing.

This module is currently under extended confirmed protection.
Extended confirmed protection prevents edits from all unregistered editors and registered users with fewer than 30 days tenure and 500 edits. The policy on community use specifies that extended confirmed protection can be applied to combat disruption, if semi-protection has proven to be ineffective. Extended confirmed protection may also be applied to enforce arbitration sanctions. Please discuss any changes on the talk page; you may submit an edit request to ask for uncontroversial changes supported by consensus.

About the latest changes

See the ChangeLog

Last update: 22 April 2026
Testcases · Examples · Sandbox

The {{#invoke:params}} module is designed to be adopted by those templates that want to have a deep control of their parameters. It is particularly useful to variadic templates, to which it offers the possibility to count, list, map and propagate the parameters received without knowing their number in advance.

The module offers elegant shortcuts to non variadic templates as well. Outside templates it has very few applications; hence, if you plan to make experiments, make sure to do them from within a template, or you will not be able to see much (you can use {{Template sandbox}} for that). Under ./testcases you can find helper templates that can be specifically used for testing the module's capabilities in flexible ways. Finally, under ./doc/examples you can find some of the examples shown in this documentation page.

Note: In case your template uses {{#invoke:params}}, please add {{lua|Module:Params}} to its documentation page, so that if breaking changes will be introduced in the future the template will be easily traceable without performing an "in source" search.

Please, do not edit this module without having done extensive testing in the module's sandbox first.

General usage

Among the possibilities that the module offers there is that of performing a series of actions after additional arguments have been concatenated to templates' incoming parameters. As this makes it necessary to keep the argument slots clean from interference, instead of named arguments in order to specify options this module uses piping functions (i.e. functions that expect to be piped instead of returning to the caller), or modifiers. This creates a syntax similar to the following example:

{{#invoke:params|[modifier]|[...]|[modifier]|[...]|function|[...]}}

For instance, as the name suggests, the list function lists the parameters wherewith a template was called. By default it does not add delimiters, but returns an indistinct blob of text in which keys and values are sticked to each other. However, by using the setting modifier, we are able to declare a key-value delimiter (p) and an iteration delimiter (i). And so, if we imagined a template named {{example template}} containing the following wikitext,

{{#invoke:params|setting|i/p|<br />|: |list}}

and such template were called with the following parameters,

{{example template
	| Beast of Bodmin = A large feline inhabiting Bodmin Moor
	| Morgawr = A sea serpent
	| Owlman = A giant owl-like creature
}}

the following result would be produced:

Beast of Bodmin: A large feline inhabiting Bodmin Moor
Morgawr: A sea serpent
Owlman: A giant owl-like creature

We can also do more sophisticated things; for instance, by exploiting the possibility to set a header (h) and a footer (f), we can transform the previous code into a generator of definition lists,

{{#invoke:params|setting|h/p/i/f|<dl><dt>|</dt><dd>|</dd><dt>|</dd></dl>|list}}

thus yielding:

Beast of Bodmin: A large feline inhabiting Bodmin Moor
Morgawr: A sea serpent
Owlman: A giant owl-like creature

By placing the with_name_matching modifier before the list function we will be able to filter some parameters out – such as, for instance, all parameter names that do not end with an "n":

{{#invoke:params|with_name_matching|n$|setting|h/p/i/f|<dl><dt>|</dt><dd>|</dd><dt>|</dd></dl>|list}}

Thus, the previous code will produce:

Beast of Bodmin: A large feline inhabiting Bodmin Moor
Owlman: A giant owl-like creature

This mechanism has the intrinsic advantage that it allows the concatenation of infinite modifiers. And so, in order to get the accurate result that we want to obtain we could write:

{{#invoke:params|non-sequential|with_name_matching|^B|with_name_matching|n$|with_value_matching|feline|setting|h/p/i/f|<dl><dt>|</dt><dd>|</dd><dt>|</dd></dl>|list}}

Most modifiers immediately affect what follows, while others add their action to the queue of actions that will be done last, thus affecting only the way functions behave (e.g. sequential, non-sequential, all_sorted, reassorted – these are called “flag modifiers”). A rule of thumb in the nomenclature is the following:

If a directive is an English adjective or a past participle it is a flag modifier (e.g. sequential)
If a directive is or contains an English gerundive it is a modifier (with the exception of the special, first-position-only new directive – e.g. squeezing)
If a directive is anything else (usually an English bare infinitive) it is a normal non-piping function (e.g. list_values)

The two flag modifiers sequential and non-sequential refer to a technical jargon used in wikitext: given a parameter list, the subgroup of sequential parameters is constituted by the largest group of consecutive numeric parameters starting from |1= – this is known as the parameters' "sequence". A parameter list that does not have a first parameter specified does not possess a sequence.

Considerations on code style

Normally on Wikipedia, when templates are written across multiple lines in block style, by convention the pipe sign (|) is written on the left side of each new line, as in the following example:

{{cite book
	| last = Bloggs
	| first = Joe
	| author-link = Joe Bloggs
	| date = 1974
	| title = Book of Bloggs
}}

Doing the same with {{#invoke:params}} however is often impossible, because the module tends to preserve trailing spaces and new lines in all its arguments except in modifier and function names (and, accordingly, a newline character would be parsed as belonging to the last parameter of each line). Because of this, the only safe and meaningful way to invoke this module in block style is by appending the pipe sign at the end of the line, right before a modifier name or a function name, as in the following example:

{{#invoke:params|
	all_sorted|
	excluding_non-numeric_names|
	mapping_by_replacing|[^abdlp]+||
	mapping_by_replacing|a|⏒ ||plain|
	mapping_by_replacing|b|⏑ ||plain|
	mapping_by_replacing|d|⏔ ||plain|
	mapping_by_replacing|l|‒ ||plain|
	mapping_by_replacing|p|⏖ ||plain|
	trimming_values|
	mapping_by_replacing|%s+|&nbsp;|
	setting|h/i/f|<big>&nbsp;|&nbsp;&#124; |&nbsp;</big>|
	list_values
}}

Prototyping new templates

In designing new templates or exploring the module's capabilities, there are two possible approaches that allow to simulate the incoming parameters direcly in a preview window—without having to save the changes first and then test them from a different page. The first approach consists in temporarily exploiting the <includeonly>...</includeonly> and <noinclude>...</noinclude> tags properly to include the template's transclusion as well, the second approach consists in temporarily relying on the imposing modifier.

For instance, given a template named {{My template}}, whose wikitext is {{#invoke:params|value_of|foo}}, to simulate the transclusion {{My template|one|two|three|foo=bar}}, it is possible to write, temporarily,

<includeonly>{{#invoke:params|value_of|foo}}</includeonly><noinclude>{{My template|one|two|three|foo=bar}}</noinclude>

or, equivalently,

{{#invoke:params|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|foo|bar|
	value_of|foo
}}

and then click on “Show preview”. In both cases, the final template must be eventually saved as:

<includeonly>{{#invoke:params|value_of|foo}}</includeonly><noinclude>{{Documentation}}</noinclude>

Functions

Here follows the list of functions. You might want to see also § Flag modifiers and § Modifiers.

`self`

Brief: Return the name of the current template
Syntax: {{#invoke:params|self}}

This argumentless function guarantees that the name of the template invoking this module is shown, regardless if this is transcluded or not.

As a possible example, if a Wikipedia page named Page X contained only a transclusion of a template named {{foobar}}, and the latter contained the following wikitext,

{{#invoke:params|self}}

{{FULLPAGENAME}}

if we visited Template:Foobar we would see,

Template:Foobar

Template:Foobar

whereas if we visited Page X we would see:

Template:Foobar

Page X

Therefore by writing

{{#ifeq:{{#invoke:params|self}}|{{FULLPAGENAME}}
	| Page is not being transcluded
	| Page is being transcluded
}}

it is possible to understand whether a page is being transcluded or not. For most cases the <includeonly>...</includeonly> and <noinclude>...</noinclude> will offer a simpler solution, however there can be cases in which this becomes the way to go.

If Page X transcluded {{foobar 2}} and the latter were a redirect to {{foobar}}, we would still see

Template:Foobar

Page X

A typical use case of this function is that of providing stable links for editing transcluded templates. E.g.:

{{edit|{{#invoke:params|self}}|edit this template}}

Another possible use case is that of transcluding a subtemplate. E.g.:

{{{{#invoke:params|self}}/my subtemplate|foo|bar}}

`count`

Brief: Count the number of parameters wherewith a template was called
Syntax: {{#invoke:params|count}}

This function does not take arguments.

The number that this function yields depends on the modifiers that precede it. For instance, in a template that is called with both named and unnamed parameters,

{{#invoke:params|count}}

and

{{#invoke:params|sequential|count}}

will return different results.

`concat_and_call`

Brief: Prepend positive numeric arguments to the current parameters, or impose non-numeric or negative numeric arguments, then propagate everything to a custom template
Syntax: {{#invoke:params|concat_and_call|template name|[prepend 1]|[prepend 2]|[...]|[prepend n]|[named item 1=value 1]|[...]|[named item n=value n]|[...]}}

This function comes in handy in case of wrapper templates. For example, if our {{wrapper template}} had the following code,

{{#invoke:params|concat_and_call|foobar|elbow|earth|room|7=classy|hello=not today}}

and were called with,

{{wrapper template
	| one
	| two
	| three
	| hello = world
	| wind = spicy
}}

the following call to the {{foobar}} template would be performed:

{{foobar
	| elbow
	| earth
	| room
	| 7 = classy
	| 8 = one
	| 9 = two
	| 10 = three
	| wind = spicy
	| hello = not today
}}

By using the cutting modifier it is possible to impose numeric positive parameters instead of prepending them. For instance, the following code echoes all incoming parameters to {{my template}}, with the exception of |3=, which is replaced with hello world:

{{#invoke:params|cutting|3|0|concat_and_call|my template|{{{1|}}}|{{{2|}}}|hello world}}

If the numeric parameters to replace are a limited number, as in the example above, a better alternative to cutting might be imposing.

If no other argument besides the template name is provided this function simply echoes the current parameters to another template.

Note: All arguments passed to this function except the template name will not be trimmed of their leading and trailing spaces. The concat_and_call function name itself, instead, will be trimmed of its surrounding spaces.

`concat_and_invoke`

Function `concat_and_invoke` (code)
See also
Num. of arguments	Ad libitum
Not affected by	`all_sorted`, `reassorted`
`concat_and_call`, `concat_and_magic`

Brief: Prepend positive numeric arguments to the current parameters, or impose non-numeric or negative numeric arguments, then propagate everything to a custom module
Syntax: {{#invoke:params|concat_and_invoke|module name|function name|[prepend 1]|[prepend 2]|[...]|[prepend n]|[named item 1=value 1]|[...]|[named item n=value n]|[...]}}

Exactly like concat_and_call, but invokes a module function instead of calling a template.

Note: All arguments passed to this function except the module name and the function name will not be trimmed of their leading and trailing spaces. The concat_and_invoke function name itself, instead, will be trimmed of its surrounding spaces.

`concat_and_magic`

Function `concat_and_magic` (code)
See also
Num. of arguments	Ad libitum
Not affected by	`all_sorted`, `reassorted`
`concat_and_call`, `concat_and_invoke`

Brief: Prepend positive numeric arguments to the current parameters, or impose non-numeric or negative numeric arguments, then propagate everything to a custom parser function
Syntax: {{#invoke:params|concat_and_magic|parser function|[prepend 1]|[prepend 2]|[...]|[prepend n]|[named item 1=value 1]|[...]|[named item n=value n]|[...]}}

Exactly like concat_and_call, but calls a parser function instead of a template.

Note: All arguments passed to this function except the magic word will not be trimmed of their leading and trailing spaces. The concat_and_magic function name itself, instead, will be trimmed of its surrounding spaces.

`value_of`

Function `value_of` (code)
See also
Num. of arguments	1
Relevant function-only variables	`h`, `f`, `n`
Not affected by	`all_sorted`, `reassorted`
`list_values`, `list_maybe_with_names`, `coins`, `unique_coins`

Brief: Get the value of a single parameter
Syntax: {{#invoke:params|value_of|parameter name}}

Without modifiers this function is similar to writing {{{parameter name|}}}. With modifiers, however, it allows reaching parameters that would be unreachable without knowing their number in advance. For instance, writing

{{#invoke:params|cutting|-2|0|value_of|1}}

will expand to the value of the second-last sequential parameter, independently of how many parameters the template was called with. If no matching parameter is found this function expands to nothing. A header (h), a footer (f), and a fallback text (n) can be declared via the setting modifier – the strings assigned to the key-value pair delimiter (p), the iteration delimiter (i), the last iteration delimiter (l) and the "serial-comma-like" last iteration delimiter (s) will be ignored.

For instance, the {{If then show}} template could be rewritten as

{{#invoke:params|with_value_not_matching|^%s*$|setting|h/f/n|{{{3|}}}|{{{4|}}}|{{{2|}}}|value_of|1}}

Simplifying, the following wikitext expands to the first parameter that is not empty:

{{#invoke:params|with_value_not_matching||strict|squeezing|value_of|1}}

Whereas the following wikitext expands to the first parameter that is not blank (i.e. neither empty nor containing only whitespaces)

{{#invoke:params|with_value_not_matching|^%s*$|squeezing|value_of|1}}

`list`

Function `list` (code)
See also
Num. of arguments	0
Sortable	Yes
Relevant function-only variables	`h`, `p`, `i`, `l`, `f`, `n`
`list_values`, `list_maybe_with_names`

Brief: List the template parameters (both their names and their values)
Syntax: {{#invoke:params|list}}

This function does not take arguments.

If the setting modifier was not placed earlier, this function will not add delimiters, but will return an indistinct blob of text in which keys and values are sticked to each other. A header (h), a key-value pair delimiter (p), an iteration delimiter (i), a last iteration delimiter (l), a "serial-comma-like" last iteration delimiter (s), a footer (f), and a fallback text (n) can be declared via setting.

For example, the following code

{{#invoke:params|setting|h/i/p/f/n|'''Parameters passed:''' |); | (|)|'''No parameters were passed'''|list}}

will generate an output similar to the following.

Parameters passed: Owlman (A giant owl-like creature); Beast of Bodmin (A large feline inhabiting Bodmin Moor); Morgawr (A sea serpent)

`list_values`

Function `list_values` (code)
See also
Num. of arguments	0
Sortable	Yes
Often preceeded by	`sequential`
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`list`, `list_maybe_with_names`, `value_of`, `coins`, `unique_coins`, `{{#invoke:separated entries}}`

Brief: List the values of the incoming parameters
Syntax: {{#invoke:params|list_values}}

This function does not take arguments.

The sequential modifier often accompanies this function. If the setting modifier was not placed earlier, this function will not add delimiters, but will return an indistinct blob of text in which values are sticked to each other. A header (h), an iteration delimiter (i), a last iteration delimiter (l), a "serial-comma-like" last iteration delimiter (s), a footer (f), and a fallback text (n) can be declared via setting – the string assigned to the key-value pair delimiter (p) will be ignored.

For example, the following code

{{#invoke:params|setting|h/i/f/n|'''Values of parameters passed:''' |; |.|'''No parameters were passed'''|list_values}}

will generate an output similar to the following.

Values of parameters passed: A giant owl-like creature; A large feline inhabiting Bodmin Moor; A sea serpent.

This function covers and extends all the cases covered by {{#invoke:Separated entries|main}}. For instance, the following two examples with “ + ” as delimiter and “ ... ” as conjunction produce a similar result:

{{#invoke:separated entries|main|separator= + |conjunction= ... }}
{{#invoke:params|sequential|trimming_values|with_value_not_matching||strict|squeezing|setting|i/l| + | ... |list_values}}

`list_maybe_with_names`

Function `list_maybe_with_names` (code)
See also
Num. of arguments	0
Sortable	Yes
Often preceeded by	`sequential`
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`list`, `list_values`, `value_of`, `coins`, `unique_coins`, `{{#invoke:separated entries}}`

Brief: List the values of sequential parameters and the names and the values of non-sequential parameters
Syntax: {{#invoke:params|list_maybe_with_names}}

This function does not take arguments. It is a combination of list and list_values: if a parameter belongs to the parameter sequence only its value will be shown, otherwise both its name and its value will be shown. If the setting modifier was not placed earlier, this function will not add delimiters, but will return an indistinct blob of text in which keys and values are sticked to each other. A header (h), a key-value pair delimiter (p), an iteration delimiter (i), a last iteration delimiter (l), a "serial-comma-like" last iteration delimiter (s), a footer (f), and a fallback text (n) can be declared via setting.

For example, the following code in {{My template}},

{{#invoke:params|setting|h/i/p/f/n|'''Parameters passed:''' |; |→|.|'''No parameters were passed'''|list_maybe_with_names}}

when transcluded as {{My template|one|two|three|four|foo=bar|hello=world}}, will generate an output similar to the following.

Parameters passed: one; two; three; four; hello→world; foo→bar.

This function is particularly useful to mimic the natural transclusion of templates.

`coins`

Function `coins` (code)
See also
Num. of arguments	Ad libitum
Sortable	Yes
Often preceeded by	`sequential`, `trimming_values`
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`unique_coins`, `list_values`, `value_of`

Brief: Associate custom strings to possible parameter values and list the custom string when the associated value is present
Syntax: {{#invoke:params|coins|[first coin = value 1]|[second coin = value 2]|[...]|[last coin = value N]}}

This function is identical to the unique_coins function, except that it allows the repetition of identical flags. See there for more information.

`unique_coins`

Function `unique_coins` (code)
See also
Num. of arguments	Ad libitum
Sortable	Yes
Often preceeded by	`sequential`, `trimming_values`
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`coins`, `list_values`, `value_of`

Brief: Associate custom strings to possible parameter values and list the custom string when the associated value is present, but not more than once
Syntax: {{#invoke:params|unique_coins|[first coin = value 1]|[second coin = value 2]|[...]|[last coin = value N]}}

This function is used to detect the existence of flag parameters. For this reason, it is often accompanied by the sequential modifier (or, equivalently, by ...|excluding_non-numeric_names|clearing|...). For a similar function that allows the repetition of identical flags, see the coins function.

A typical use case of this function is that of constructing URLs. For example, the following template named {{example template}} checks for the html, xml, comments and removenowiki flags in order to append respectively the following strings to the final URL: &wpGenerateRawHtml=1, &wpGenerateXml=1, &wpRemoveComments=0, &wpRemoveNowiki=1.

{{#if:{{{input|}}}
	| <span class="plainlinks">[{{fullurl:Special:ExpandTemplates|wpInput={{urlencode:{{{input}}}|QUERY}}{{#if:{{{title|}}}|&wpContextTitle={{urlencode:{{{title}}}|QUERY}}}}{{#invoke:params|excluding_non-numeric_names|clearing|sequential|trimming_values|unique_coins
		| html = &wpGenerateRawHtml=1
		| xml = &wpGenerateXml=1
		| comments = &wpRemoveComments=0
		| removenowiki = &wpRemoveNowiki=1
	}}}} {{#if:{{{label|}}}|{{{label|}}}|Expand <code>{{{input}}}</code>}}]</span>
	| {{Error|Error: The {{para|input}} parameter is missing.}}
}}

And so, when transcluded as,

{{example template|comments|xml
	| input = Hello world {<nowiki />{#time:r{{!}}now}<nowiki />}
}}

it will generate the following output:

Expand Hello world {{#time:r|now}}

A copy of the example above is available at {{./doc/examples/link to expanded template}}.

If the setting modifier was not placed earlier, this function will not add delimiters, but will return an indistinct blob of text in which values are sticked to each other. A header (h), an iteration delimiter (i), a last iteration delimiter (l), a "serial-comma-like" last iteration delimiter (s), a footer (f), and a fallback text (n) can be declared via setting – the string assigned to the key-value pair delimiter (p) will be ignored.

`call_for_each`

Function `call_for_each` (code)
See also
Num. of arguments	Ad libitum
Sortable	Yes
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`call_for_each_value`, `mapping_by_calling`, `invoke_for_each`, `magic_for_each`, `call_for_each_group`, `{{#invoke:for loop}}`, `{{for loop}}`

Brief: For each parameter passed to the current template, call a custom template with at least two parameters (key and value)
Syntax: {{#invoke:params|call_for_each|template name|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...] }}

Some functions are like shortcuts. The X_for_each|F functions are similar to mapping_by_X(ing)|F|(names_and_values|)list_values. The latter syntax (i.e. the modifier version) allows a values_and_names flag to invert the order from key-value to value-key.

All unnamed arguments following the template name will be placed after the key-value pair. Named arguments will be passed verbatim. A header (h), an iteration delimiter (i), a last iteration delimiter (l), a "serial-comma-like" last iteration delimiter (s), a footer (f), and a fallback text (n) can be declared via the setting modifier – the string assigned to the key-value pair delimiter (p) will be ignored.

Calling a template for each key-value pair with

{{#invoke:params|sequential|call_for_each|foobar}}

will be different from writing

{{#invoke:params|sequential|for_each|{{foobar|$#|$@}}}}

In the first example each key-value pair will be passed to the {{foobar}} template, while in the second example the $# and $@ tokens will be expanded after the {{foobar}} template has been called. In most cases this will make no difference, however there are several situations where it will lead to nonsensical results.

Note: All arguments passed to this function except the template name will not be trimmed of their leading and trailing spaces. The call_for_each function name itself, instead, will be trimmed of its surrounding spaces.

`invoke_for_each`

Function `invoke_for_each` (code)
See also
Num. of arguments	Ad libitum
Sortable	Yes
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`invoke_for_each_value`, `mapping_by_invoking`, `call_for_each`, `magic_for_each`

Brief: For each parameter passed to the current template, invoke a custom module function with at least two arguments (key and value)
Syntax: {{#invoke:params|invoke_for_each|module name|module function|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}

Exactly like call_for_each, but invokes a module instead of calling a template.

Invoking a module function for each key-value pair with

{{#invoke:params|sequential|invoke_for_each|foobar|main}}

will be different from writing

{{#invoke:params|sequential|for_each|{{#invoke:foobar|main|$#|$@}}}}

In the first example each key-value pair will be passed to the {{#invoke:foobar|main}} module function, while in the second example the $# and $@ tokens will be expanded after the module function has been invoked. There might be cases in which this will make no difference, however there are several situations where it will lead to nonsensical results.

Note: All arguments passed to this function except the module name and the function name will not be trimmed of their leading and trailing spaces. The invoke_for_each function name itself, instead, will be trimmed of its surrounding spaces.

`magic_for_each`

Function `magic_for_each` (code)
See also
Num. of arguments	Ad libitum
Sortable	Yes
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`magic_for_each_value`, `mapping_by_magic`, `call_for_each`, `invoke_for_each`

Brief: For each parameter passed to the current template, call a magic word with at least two arguments (key and value)
Syntax: {{#invoke:params|magic_for_each|parser function|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}

Exactly like call_for_each, but calls a parser function instead of a template.

Note: All arguments passed to this function except the magic word will not be trimmed of their leading and trailing spaces. The magic_for_each function name itself, instead, will be trimmed of its surrounding spaces.

`call_for_each_value`

Function `call_for_each_value` (code)
See also
Num. of arguments	Ad libitum
Sortable	Yes
Often preceeded by	`sequential`
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`call_for_each`, `mapping_by_calling`, `invoke_for_each_value`, `magic_for_each_value`, `call_for_each_group`, `{{#invoke:for loop}}`, `{{for loop}}`

Brief: For each parameter passed to the current template, call a custom template with at least one parameter (i.e. the parameter's value)
Syntax: {{#invoke:params|call_for_each_value|template name|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}

The sequential modifier often accompanies this function. All unnamed arguments following the template name will be appended after the value parameter. Named arguments will be passed verbatim. A header (h), an iteration delimiter (i), a last iteration delimiter (l), a "serial-comma-like" last iteration delimiter (s), a footer (f), and a fallback text (n) can be declared via the setting modifier – the string assigned to the key-value pair delimiter (p) will be ignored.

For example, calling {{tl}} with each parameter can be done by writing

{{#invoke:params|sequential|setting|i|, |call_for_each_value|tl}}

This will be different from writing

{{#invoke:params|sequential|setting|i|, |for_each|{{tl|$@}}}}

In the first example each value will be passed to the {{tl}} template, while in the second example the $@ token will be expanded after the {{tl}} template has been called. Here this will make no difference, however there are several situations where it will lead to nonsensical results.

Note: All arguments passed to this function except the template name will not be trimmed of their leading and trailing spaces. The call_for_each_value function name itself, instead, will be trimmed of its surrounding spaces.

`invoke_for_each_value`

Function `invoke_for_each_value` (code)
See also
Num. of arguments	Ad libitum
Sortable	Yes
Often preceeded by	`sequential`
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`call_for_each_value`, `mapping_by_invoking`, `invoke_for_each`, `magic_for_each_value`

Brief: For each parameter passed to the current template, invoke a custom module function with at least one argument (i.e. the parameter's value)
Syntax: {{#invoke:params|invoke_for_each_value|module name|module function|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}

Exactly like call_for_each_value, but invokes a module instead of calling a template.

Invoking a module function for each value with

{{#invoke:params|sequential|invoke_for_each_value|foobar|main}}

will be different from writing

{{#invoke:params|sequential|for_each|{{#invoke:foobar|main|$@}}}}

In the first example each value will be passed to the {{#invoke:foobar|main}} module function, while in the second example the $@ token will be expanded after the module function has been invoked. There might be cases in which this will make no difference, however there are several situations where it will lead to nonsensical results.

Note: All arguments passed to this function except the module name and the function name will not be trimmed of their leading and trailing spaces. The invoke_for_each_value function name itself, instead, will be trimmed of its surrounding spaces.

`magic_for_each_value`

Function `magic_for_each_value` (code)
See also
Num. of arguments	Ad libitum
Sortable	Yes
Often preceeded by	`sequential`
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`call_for_each_value`, `mapping_by_magic`, `invoke_for_each_value`, `magic_for_each`

Brief: For each parameter passed to the current template, call a magic word with at least one argument (i.e. the parameter's value)
Syntax: {{#invoke:params|magic_for_each_value|parser function|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}

Exactly like call_for_each_value, but calls a parser function instead of a template.

For example, if a template had the following code,

{{#invoke:params|sequential|setting|ih|&preloadparams%5b%5d{{=}}|magic_for_each_value|urlencode|QUERY}}

and were transcluded as {{example template|hello world|àèìòù|foobar}}, the {{urlencode:...|QUERY}} parser function would be called for each incoming parameter as first argument and with QUERY as second argument, and finally the returned text would be prefixed with &preloadparams%5b%5d=. This would generate,

&preloadparams%5b%5d=hello+world&preloadparams%5b%5d=%C3%A0%C3%A8%C3%AC%C3%B2%C3%B9&preloadparams%5b%5d=foo+bar

which can be used to allow the creation of pages with preloaded text and parameters.

Note: All arguments passed to this function except the magic word will not be trimmed of their leading and trailing spaces. The magic_for_each_value function name itself, instead, will be trimmed of its surrounding spaces.

`call_for_each_group`

Function `call_for_each_group` (code)
See also
Num. of arguments	Ad libitum
Often preceeded by	`all_sorted`, `reassorted`
Sortable	Yes
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`grouping_by_calling`, `call_for_each`, `call_for_each_value`, `{{#invoke:for loop}}`, `{{for loop}}`

Brief: Call a custom template for each group of parameters that have the same numeric suffix
Syntax: {{#invoke:params|call_for_each_group|template name|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...] }}

The custom template will be repeatedly called with the numeric id of the group (i.e. the numeric suffix) as parameter zero (i.e. {{{0}}}). This will be an empty string for the group of incoming parameters that do not have a numeric suffix. A hyphen before the numeric suffix will be interpreted as a minus sign (and therefore the group id will be treated as a negative number). Numeric incoming parameters will be treated as if their prefix is an empty string (these can be captured using {{{}}} or {{{|fallback text}}} in the callback template). Spaces between the prefix and the numeric suffix will be ignored (therefore writing |foobar123= will be identical to writing |foobar 123= – in case of collisions one of the two values will be discarded). In the unlikely scenario that the prefix is itself a number (e.g. |1 1=, |2 1=, etc.), if this is 0 or a negative number it will be decreased by one unit in order to leave the parameter zero undisturbed (so 0 will become -1, -1 will become -2, and so on – if needed, you can use ...|purging|0|1|... in the callback template to renormalize these numbers).

All unnamed arguments that follow the template name in the invocation of this module will appear as sequential parameters in each call. Named arguments will be passed verbatim. Both named and unnamed arguments passed to this function will be given precedence in case of collisions. Numeric argument names below 1 will be decreased by one unit (i.e. ...|call_for_each_group|example template|0=Hello world|... will become |-1=Hello world in the callback template – see above).

A header (h), an iteration delimiter (i), a last iteration delimiter (l), a "serial-comma-like" last iteration delimiter (s), a footer (f), and a fallback text (n) can be declared via the setting modifier – the string assigned to the key-value pair delimiter (p) will be ignored.

If you are a module writer, you might recognize some distant similarities between this function and TableTools.affixNums.

For example, if a template named {{foobar}} contained the following code,

{{#invoke:params|reassorted|call_for_each_group|example template|hello|world|foo=bar}}

writing

{{foobar
	| 1 = Lorem
	| 2 = ipsum
	| bicycle-1 = dolor
	| bicycle1 = sit
	| boat1 = amet
	| car2 = consectetur
	| bicycle2 = adipiscing
	| other = elit
	| sunscreen = vestibulum
	| = ultricies
	| foo1 = neque nisl
}}

will be equivalent to writing

{{example template
	| 0 =
	| 1 = hello
	| 2 = world
	| = ultricies
	| foo = bar
	| other = elit
	| sunscreen = vestibulum
}}{{example template
	| 0 = -1
	| 1 = hello
	| 2 = world
	| bicycle = dolor
	| foo = bar
}}{{example template
	| 0 = 1
	| 1 = hello
	| 2 = world
	| = Lorem
	| bicycle = sit
	| boat = amet
	| foo = bar
}}{{example template
	| 0 = 2
	| 1 = hello
	| 2 = world
	| = ipsum
	| bicycle = adipiscing
	| car = consectetur
	| foo = bar
}}

The modifiers sequential, non-sequential, all_sorted and reassorted will affect what groups of parameters will be iterated, not what parameters will be grouped. Before calling this function you will likely want to reduce the list of parameters via one of the with_*_matching group of modifiers (for instance ...|with_name_matching|.%-%d+$|or|[^%-]%d+$|call_for_each_group|... leaves only the parameters in which both the prefix and the numeric suffix are not empty strings). The reassorted modifier often accompanies this function.

Warning In writing templates, there is often the habit of signaling multilevel substitutions using the {{{|safesubst:}}} notation. This is a dangerous practice, because {{{|safesubst:}}} means "write the parameter with an empty name, otherwise write safesubst:". Due to the fact that call_for_each_group can pass parameters with an empty name, a callback template should never use {{{|safesubst:}}} to notate multilevel substitutions, but should use instead safesubst:<noinclude />. Not following this advice can lead to bugs that are hard to debug.

At {{./doc/examples/list of authors}} you can find an example of how to use this function to list authors the same way {{Cite book}} does. For instance, writing

{{module:params/doc/examples/list of authors
	| last1 = Playfair
	| first1 = I. S. O.
	| author-link1 = Ian Stanley Ord Playfair
	| last2 = Stitt
	| first2 = G. M. S.
	| last3 = Molony
	| first3 = C. J. C.
	| last4 = Toomer
	| first4 = S. E.
}}

will generate

Playfair, I. S. O.; Stitt, G. M. S.; Molony, C. J. C. & Toomer, S. E.

See also {{./doc/examples/tablebox}} for an example of how to exploit this function to create infoboxes, and {{./doc/examples/four cells per row table}} for an example of how to exploit this function to create n-column tables.

Note: All arguments passed to this function except the template name will not be trimmed of their leading and trailing spaces. The call_for_each_group function name itself, instead, will be trimmed of its surrounding spaces.

`for_each`

Function `for_each` (code)
See also
Num. of arguments	1
Sortable	Yes
Relevant function-only variables	`h`, `i`, `l`, `f`, `n`
`list`, `list_values`, `list_maybe_with_names`, `{{#invoke:for nowiki}}`, `{{for nowiki}}`, `{{expand wikitext}}`

Brief: For each parameter passed to the current template, expand all occurrences of $# and $@ within a given text as key and value respectively
Syntax: {{#invoke:params|for_each|wikitext}}

Example:

{{#invoke:params|for_each|Arg name: $#, Arg value: $@}}

The text returned by this function is not expanded further (currently this module does not offer an expand_for_each function). If you need wikitext expansion, use either concat_and_call to propagate the incoming parameters altogether to the {{for nowiki}} template, or mapping_by_calling to propagate the incoming parameters one by one to {{expand wikitext}}.

Example #1 (wikitext expanded via the {{for nowiki}} template – suggested):

{{#invoke:params|excluding_non-numeric_names|concat_and_call|for nowiki|<br />|<nowiki>Parameter value is "{{{1}}}"</nowiki>}}

Example #2 (wikitext expanded via the {{expand wikitext}} template – less efficient but more flexible):

{{#invoke:params|setting|i|<br />|mapping_by_calling|expand wikitext|names_and_values_as|2|3|
	let|1|<nowiki>Parameter name is "{{{2}}}", parameter value is "{{{3}}}"</nowiki>|
	let|unstrip|yes|
	list_values}}

Note: The argument passed to this function will not be trimmed of its leading and trailing spaces. The for_each function name itself, instead, will be trimmed of its surrounding spaces.

Flag modifiers (piping functions)

The following are flag modifiers, i.e. functions that add their action to the queue of actions that will be done last, and which expect to be piped instead of returning to the caller. Each of them can be followed by either another flag modifier or a modifier or a non-piping function. The order in which flag modifiers appear has no consequences. The actions that flags do affects only functions, but do not affect modifiers.

`sequential`

Modifier `sequential` (code)
See also
Num. of arguments	0
Repeatable	No
Conflicts with	`non-sequential`, `all_sorted`, `reassorted`
`non-sequential`, `all_sorted`, `reassorted`, `squeezing`, `filling_the_gaps`, `clearing`

Brief: (In functions only, does not affect modifiers) Reduce the parameter list to the subgroup of consecutive parameters that follow |1=
Syntax: {{#invoke:params|sequential|pipe function name}}

Example:

{{#invoke:params|sequential|count}}

This modifier does not take arguments besides the name of the function that will follow. Its purpose is only that of telling functions to iterate using Lua ipair() instead of pair(). It does not remove any parameter from the list (to do that, you will need to use ...|excluding_non-numeric_names|clearing|... instead). Unless there are many intermediate operations that repeatedly iterate through all parameters, simply flagging the parameter list as sequence-only is usually faster than actually removing non-sequential parameters.

Using sequential together with non-sequential will generate an error.

Note: Like non-sequential, the sequential modifier permanently marks a query. For instance, writing {{#invoke:params|sequential|with_name_not_matching|1|...}} will first mark the query as "sequential", then will discard the first element from the sequence (leaving all the others intact). And so, no matter how many other parameters will be present, nothing will be shown.

`non-sequential`

Modifier `non-sequential` (code)
See also
Num. of arguments	0
Repeatable	No
Conflicts with	`sequential`
`sequential`, `all_sorted`, `reassorted`

Brief: (In functions only, does not affect modifiers) Reduce the parameter list by discarding the subgroup of consecutive parameters that follow |1=
Syntax: {{#invoke:params|non-sequential|pipe function name}}

Example:

{{#invoke:params|non-sequential|setting|ih/p|{{!}}|{{=}}|list}}

This modifier does not take arguments besides the name of the function that will follow.

Using non-sequential together with sequential will generate an error.

Note: Like sequential, the non-sequential modifier permanently marks a query, and no matter what transformations will follow (see squeezing) the parameters' "sequence" will not be shown.

`all_sorted`

Modifier `all_sorted` (code)
See also
Num. of arguments	0
Repeatable	No
Conflicts with	`sequential`, `reassorted`
Has no effects on	`count`, `value_of`, `concat_and_call`, `concat_and_invoke`, `concat_and_magic`
Natural sort order, `reassorted`, `sequential`, `sorting_sequential_values`

Brief: (IN FUNCTIONS ONLY, DOES NOT AFFECT MODIFIERS) When the time will come, all parameters will be dispatched sorted: first the numeric ones in ascending order, then the rest in natural order
Syntax: {{#invoke:params|all_sorted|pipe function name}}

Note: This modifier sorts the way functions iterate across all parameters based on their names. If you want to sort sequential parameters based on their values, see sorting_sequential_values.

Example:

{{#invoke:params|all_sorted|setting|ih/p|{{!}}|{{=}}|list}}

This modifier does not take arguments besides the name of the function that will follow.

Normally only sequential parameters are dispatched sorted, whereas non-sequential ones are dispatched randomly. The all_sorted modifier ensures that nothing is left out of (natural) order. Attention must be paid to the fact that parameters whose name is a negative number will appear first. To avoid this the squeezing modifier can be used.^[1]

The all_sorted modifier only affects the way parameters are shown, but has no effects on functions that do not iterate or cannot impose an order, such as:

count
value_of
concat_and_call
concat_and_invoke
concat_and_magic

Note: The all_sorted modifier cannot be used with functions that propagate several parameters together in a single call, like concat_and_call, concat_and_invoke, and concat_and_magic, because during a call the order of arguments is always lost. For the same reason, it is not possible to guess the order of named parameters a template was transcluded with.

`reassorted`

Modifier `reassorted` (code)
See also
Num. of arguments	0
Repeatable	No
Conflicts with	`sequential`, `all_sorted`
Has no effects on	`count`, `value_of`, `concat_and_call`, `concat_and_invoke`, `concat_and_magic`
Natural sort order, `all_sorted`, `sequential`, `sorting_sequential_values`

Brief: (IN FUNCTIONS ONLY, DOES NOT AFFECT MODIFIERS) When the time will come, all parameters will be dispatched sorted: first non numeric ones in natural order, then the numeric ones in ascending order
Syntax: {{#invoke:params|reassorted|pipe function name}}

This modifier is similar to all_sorted, but numbers are iterated last (as in "bar, foo, hello, zebra, 1, 2, 3, …").

Note: The reassorted modifier cannot be used with functions that propagate several parameters together in a single call, like concat_and_call, concat_and_invoke, and concat_and_magic, because during a call the order of arguments is always lost. For the same reason, it is not possible to guess the order of named parameters a template was transcluded with.

Modifiers (piping functions)

The following are modifiers, i.e. functions that expect to be piped instead of returning to the caller. Each of them can be followed by either another modifier or a flag modifier or a non-piping function. The actions that modifiers do are done sequentially, in the same order chosen during the invocation of this module.

`setting`

Num. of arguments 2–8 (variable)

Repeatable Yes

Memory slots

`p`	Key-value delimiter
`i`	Iteration delimiter
`l`	Last iteration delimiter
`h`	Header text
`f`	Footer text
`n`	Fallback text
`s`	"Serial-comma-like" last iteration delimiter

Brief: Define glue strings
Syntax: {{#invoke:params|setting|directives|...|pipe function name}}

This modifier allows some internal variables to be set and later be used (currently only by functions). It takes a variable number of arguments, relying on the first argument to understand how many other arguments to read. A few examples will introduce it better than words:

{{#invoke:params|setting|i|{{!}}|list_values}}
↳ Set the value of iteration delimiter to |, then list all values
{{#invoke:params|setting|ih|{{!}}|list_values}}
↳ Set the value of both header text and iteration delimiter to |, then list all values
{{#invoke:params|setting|ih/p|{{!}}|{{=}}|list}}
↳ Set the value of both header text and iteration delimiter to |, set key-value pair delimiter to =, then list all parameters
{{#invoke:params|setting|ih/p/n|{{!}}|{{=}}|No parameters were passed|list}}
↳ Set the value of both header text and iteration delimiter to |, set key-value pair delimiter to =, set fallback text to No parameters were passed, then list all parameters

The first argument is a slash-separated list of lists of slots to assign; one slot is referred by exactly one character and each list of slots maps exactly one argument. A slot indicates which internal variable to set. If more than one slot is aggregated within the same slash-separated list the same text will be assigned to more than one variable.

The slots available are the following:

Slots	Variable	Description
`p`	Key-value pair delimiter	The string of text that will be placed between each parameter name and its value; it is never inserted by functions that only iterate between values, or by functions that pass the key-value pairs to external calls.
`i`	Iteration delimiter	The string of text that will be placed between each iteration; it is never inserted unless there are two or more parameters to show when `l` is not given, or three or more parameters when `l` is given.
`l`	Last iteration delimiter	The string of text that will be placed between the second last and the last iteration; it is never inserted unless there are two or more parameters to show; if omitted it defaults to `i`.
`s`	"Serial-comma-like" last iteration delimiter	The string of text that will be placed between the second last and the last iteration when there are three or more parameters to show; if omitted it defaults to `l`.
`h`	Header text	The string of text that will be placed before the iteration begins; it is never inserted if there are no parameters to show.
`f`	Footer text	The string of text that will be placed after the iteration is over; it is never inserted if there are no parameters to show.
`n`	Fallback text	The string of text that will be placed if there are no parameters to show.

All space characters in the directives argument are discarded. Therefore writing {{#invoke:params|setting|ih/p|...}} will be equivalent to writing

{{#invoke:params|setting| i
	h	/ p |...}}

In theory, instead of assigning different arguments at once (i.e. {{...|setting|ih/p|{{!}}|{{=}}|...}}), it is possible to write separate invocations of setting for each argument, as in {{...|setting|ih|{{!}}|setting|p|{{=}}...}}. This method however will be slightly less efficient.

The s slot has been created with the Oxford comma in mind. For instance, the following imaginary {{Foobar see also}} template adds a comma before the "and" conjunction when more than two page names are provided:

{{Hatnote|{{{altphrase|Foobar see also}}}: {{#if:{{{1|}}}
	| {{#invoke:params|sequential|trimming_values|with_value_not_matching||strict|squeezing|setting|i/l/s|, | and |, and |for_each|[[$@]]}}
	| {{Error|{{tl|Foobar see also}} requires at least one page name}}
}}}}

You can find this example at {{./doc/examples/Oxford comma}}. Thus, {{module:params/doc/examples/Oxford comma|Latin|English|German|Italian}} will generate

Note: The setting modifier name will be trimmed of its surrounding spaces. The directives argument will be stripped of all space characters, including internal spaces. All other arguments passed to this modifier will be parsed verbatim (i.e. leading and trailing spaces will not be removed).

`squeezing`

Modifier `squeezing` (code)
See also
Num. of arguments	0
Repeatable	Yes
`filling_the_gaps`, `sequential`, `clearing`, `TableTools.compressSparseArray`

Brief: Rearrange all parameters that have numeric names to form a compact sequence starting from 1, keeping the same order
Syntax: {{#invoke:params|squeezing|pipe function name}}

Example:

{{#invoke:params|squeezing|sequential|setting|i/p|<br />|: |list}}

This modifier does not take arguments besides the name of the function that will follow. If you are a module writer, you might recognize some similarities between this function and TableTools.compressSparseArray.

The following three concatenations will lead to the same result of discarding all parameters with numeric names:

{{...|excluding_numeric_names|...}}
{{...|with_name_not_matching|^%-?%d+$|...}}
{{...|non-sequential|squeezing|...}}
{{...|squeezing|non-sequential|...}}

The first solution is the most optimized one. Furthermore, in the last two solutions the numeric parameters are discarded just before the final function is invoked (sometimes this might be a wanted result).

`filling_the_gaps`

Modifier `filling_the_gaps` (code)
See also
Num. of arguments	0
Repeatable	Yes
`squeezing`, `sequential`, `clearing`

Brief: Assign an empty string to all undefined numeric parameters between 1 or a lower numeric parameter name provided and the maximum numeric parameter provided
Syntax: {{#invoke:params|filling_the_gaps|pipe function name}}

Example:

{{#invoke:params|filling_the_gaps|sequential|setting|i/p|<br />|: |list}}

This modifier does not take arguments besides the name of the function that will follow.

Note that when all numeric parameters are lower than 1, the gap between 1 and the lowest numeric parameter will not be filled. The following table provides some examples.

Numeric parameters provided
Before calling `filling_the_gaps`	After calling `filling_the_gaps`
`\|1=...`	`\|1=...`
`\|2=...`	`\|1=`, `\|2=...`
`\|6=...`, `\|9=...`	`\|1=`, `\|2=`, `\|3=`, `\|4=`, `\|5=`, `\|6=...`, `\|7=`, `\|8=`, `\|9=...`
`\|-5=...`, `\|-3=...`	`\|-5=...`, `\|-4=`, `\|-3=...`
`\|-5=...`, `\|-3=...`, `\|1=...`	`\|-5=...`, `\|-4=`, `\|-3=...`, `\|-2=`, `\|-1=`, `\|0=`, `\|1=...`
`\|-1=...`	`\|-1=...`
`\|-2=...`	`\|-2=...`

Note: There is a safety limit of at most 1024 undefined parameters that can be filled using this modifier.

`clearing`

Modifier `clearing` (code)
See also
Num. of arguments	0
Repeatable	Yes
Often accompanied by	`sequential`
`sequential`, `squeezing`, `filling_the_gaps`, `excluding_non-numeric_names`

Brief: Remove all numeric parameters that are not in the sequence
Syntax: {{#invoke:params|clearing|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

Unlike sequential – which affects only the way parameters are shown – this modifier actually removes all non-sequential numeric parameters, albeit leaves non-numeric parameters intact.

Example:

{{#invoke:params|clearing|setting|i/p|<br />|: |list}}

If you want to remove also non-numeric parameters, add the excluding_non-numeric_names modifier:

{{#invoke:params|clearing|excluding_non-numeric_names|setting|i/p|<br />|: |list}}

If you want instead to remove sequential parameters and leave the rest, use {{...|cutting|-1|1|...}}:

{{#invoke:params|cutting|-1|1|setting|i/p|<br />|: |list}}

`cutting`

Modifier `cutting` (code)
See also
Num. of arguments	2
Repeatable	Yes
Often accompanied by	`sequential`
`sequential`, `squeezing`, `filling_the_gaps`, `clearing`, `cropping`, `purging`, `backpurging`, `shifting`, `reversing_numeric_names`, `sorting_sequential_values`, `splicing`

Brief: Remove zero or more parameters from the beginning and the end of the parameters' sequence
Syntax: {{#invoke:params|cutting|left trim|right trim|pipe function name}}

The first argument indicates how many sequential parameters must be removed from the beginning of the parameter sequence, the second argument indicates how many sequential parameters must be removed from the end of the parameter list. If any of the two arguments contains a negative number its absolute value indicates what must be left on the opposite side – i.e. {{#invoke:params|cutting|-3|0|list}} indicates that the last three arguments must not be discarded.

Example:

{{#invoke:params|cutting|0|2|sequential|call_for_each_value|example template}}

If the absolute value of the sum of the two arguments (left and right cut) is greater than the number of sequential parameters available, the behavior will be the same as if the sum had been equal to the number of sequential parameters available, both when this is a positive value and when it is a negative value (with opposite results). After the desired sequential parameters have been discarded, all other positive numeric parameters will be shifted accordingly.

In some cases it might be necessary to concatenate more than one invocation of the cutting modifier. For instance, the following code prints the last unnamed parameter passed, but only if at least two parameters were passed:

{{#invoke:params|sequential|cutting|1|0|cutting|-1|0|list_values}}

Suggestion: Although {{#invoke:params|cutting|-1|1|...}} de facto gets rid of all sequential parameters, in most cases it is clearer and more idiomatic to write {{#invoke:params|non-sequential|...}} to obtain the same effect. The last method however cannot be used when it is important that sequential parameters are removed before a particular modifier is called, because non-sequential does not take effect until the final function is invoked. Writing instead {{#invoke:params|sequential|cutting|-1|1|...}} will leave zero arguments to show.

`cropping`

Modifier `cropping` (code)
See also
Num. of arguments	2
Repeatable	Yes
Often accompanied by	`sequential`
`sequential`, `squeezing`, `filling_the_gaps`, `clearing`, `cutting`, `purging`, `backpurging`, `shifting`, `reversing_numeric_names`, `sorting_sequential_values`, `splicing`

Brief: Remove zero or more parameters from the beginning and the end of the list of numeric parameters (not only the sequential ones)
Syntax: {{#invoke:params|cropping|left crop|right crop|pipe function name}}

This modifier is very similar to cutting, but instead of removing arguments from the extremities of the parameters' sequence, arguments will be removed counting from the first and the last numeric arguments given (i.e. |-1000=... and |1000=... in the case of {{foobar|-1000=hello|1=my|1000=darling}}). If any of the two arguments contains a negative number its absolute value indicates what must be left on the opposite side.

Example:

{{#invoke:params|cropping|2|1|sequential|call_for_each_value|example template}}

For instance, when a template transcluded as {{example template|-2=minus two|0=zero|1=one|2=two|3=three|19=nineteen|20=twenty}} uses the cutting modifier with 2 and 1 as arguments, the following parameters are left:

-2: minus two

0: zero

16: nineteen

17: twenty

If instead the template were to use the cropping modifier with 2 and 1 as arguments, as in the example above, the following parameters would be left:

0: zero

1: one

2: two

3: three

19: nineteen

If the absolute value of the sum of the two arguments (left and right crop) is greater than the difference between the largest and the lowest numeric parameters available, the behavior will be the same as if the sum had been equal to the number of numeric parameters available, both when this is a positive value and when it is a negative value (with opposite results). When sequential parameters are present among the discarded parameters, all the remaining numeric parameters greater than zero will be shifted accordingly.

`purging`

Modifier `purging` (code)
See also
Num. of arguments	2
Repeatable	Yes
Often accompanied by	`sequential`
`sequential`, `squeezing`, `filling_the_gaps`, `clearing`, `cutting`, `cropping`, `backpurging`, `shifting`, `reversing_numeric_names`, `sorting_sequential_values`, `splicing`

Brief: Remove zero or more parameters from any point of the list of numeric parameters, shifting everything accordingly
Syntax: {{#invoke:params|purging|start offset|length|pipe function name}}

The first argument indicates at which point in the parameter list the removal must begin, the second argument indicates how many parameters must be discarded among it and what lies on the right side. If the second argument contains zero or a negative number its absolute value indicates what must be left at the end of the right side of the list of numeric parameters – i.e. {{#invoke:params|purging|5|0|list}} indicates that every numeric argument whose numeric name is greater than 4 must be removed.

Example #1 (purge the first parameter):

{{#invoke:params|purging|1|1|call_for_each_value|example template}}

Example #2 (purge the second, third, and four parameters):

{{#invoke:params|purging|2|3|call_for_each_value|example template}}

`backpurging`

Modifier `backpurging` (code)
See also
Num. of arguments	2
Repeatable	Yes
Often accompanied by	`sequential`
`sequential`, `squeezing`, `filling_the_gaps`, `clearing`, `cutting`, `cropping`, `purging`, `reversing_numeric_names`, `sorting_sequential_values`, `splicing`

Brief: Remove zero or more parameters from any point of the list of numeric parameters, moving backwards and shifting everything accordingly
Syntax: {{#invoke:params|backpurging|start offset|length|pipe function name}}

The first argument indicates at which point in the parameter list the removal must begin, the second argument indicates how many parameters must be discarded among it and what lies on the left side. If the second argument contains zero or a negative number its absolute value indicates what must be left at the end of the left side of the list of numeric parameters – i.e. {{#invoke:params|backpurging|5|0|list}} indicates that every numeric argument whose numeric name is less than 6 must be removed.

Example:

{{#invoke:params|backpurging|3|1|call_for_each_value|example template}}

The following code removes all parameters with negative and zero numeric names, then lists the rest:

{{#invoke:params|backpurging|0|0|for_each|[$#: $@]}}

`shifting`

Modifier `shifting` (code)
See also
Num. of arguments	1
Repeatable	Yes
`sequential`, `squeezing`, `filling_the_gaps`, `clearing`, `cutting`, `cropping`, `purging`, `backpurging`, `reversing_numeric_names`, `sorting_sequential_values`, `splicing`

Brief: Add a positive or a negative number to all numeric parameter names
Syntax: {{#invoke:params|shifting|addend|pipe function name}}

Example:

{{#invoke:params|shifting|-2|for_each|[$#: $@]}}

Note: The shifting modifier name will be trimmed of its surrounding spaces.

`reversing_numeric_names`

Modifier `reversing_numeric_names` (code)
See also
Num. of arguments	0
Repeatable	Yes
Often accompanied by	`sequential`
`sequential`, `squeezing`, `filling_the_gaps`, `clearing`, `cutting`, `cropping`, `purging`, `backpurging`, `shifting`, `sorting_sequential_values`, `splicing`

Brief: Reverse the order of all numeric parameters (not only sequential ones), making sure that the largest numeric parameter and |1= are swapped
Syntax: {{#invoke:params|reversing_numeric_names|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

Example:

{{#invoke:params|reversing_numeric_names|for_each|[$#: $@]}}

An example that uses this function is available at {{./doc/examples/watchlist}}.

Note: If negative parameters are present this function becomes non-invertible. This means that {{#invoke:params|reversing_numeric_names|reversing_numeric_names|...}} will not restore the original parameter names, but will shift all numeric parameters so that what formerly was the smallest parameter name will now become |1=.

`sorting_sequential_values`

Modifier `sorting_sequential_values` (code)
See also
Num. of arguments	0 or 1
Repeatable	Yes
Often accompanied by	`sequential`
`sequential`, `squeezing`, `filling_the_gaps`, `clearing`, `cutting`, `cropping`, `purging`, `backpurging`, `shifting`, `reversing_numeric_names`, `all_sorted`, `reassorted`

Brief: Sort the order of sequential values
Syntax: {{#invoke:params|sorting_sequential_values|[criterion]|pipe function name}}

Note: This modifier sorts sequential parameters based on their values. If you want to sort the way functions iterate across all parameters based on their names, see all_sorted.

This modifier optionally supports one argument to specify the sorting criterion. Currently the only possible criterions are alphabetically, for ordering sequential values in alphabetical sort order, and naturally, for ordering sequential values in natural sort order. If this argument is omitted it defaults to alphabetically.

Example (alphabetical sort order):

{{#invoke:params|sorting_sequential_values|for_each|[$#: $@]}}

Example (natural sort order):

{{#invoke:params|sorting_sequential_values|naturally|for_each|[$#: $@]}}

`splicing`

Modifier `splicing` (code)
See also
Num. of arguments	Ad libitum (min. 2)
Repeatable	Yes
`imposing`, `providing`, `sequential`, `squeezing`, `filling_the_gaps`, `clearing`, `cutting`, `cropping`, `purging`, `backpurging`, `shifting`, `reversing_numeric_names`, `mirroring_numeric_names`, `pivoting_numeric_names`, `swapping_numeric_names`, `discarding`, `all_sorted`, `reassorted`, `new`

Brief: Add or remove numeric parameters from any position, shifting the list of numeric parameters accordingly
Syntax: {{#invoke:params|splicing|[add to position]|position|increment|[number of elements to write]|...|pipe function name}}

This modifier is able to resize the array of numeric parameters and write new parameters in any given position. It constitutes the only way this module has to insert numeric parameters and make space for them.

For instance, if a template was called as {{My template|one|two|three}} and—independently of how many sequential parameters were passed—you want to insert ...|hello|world|... before the last sequential parameter (thus creating in this case {{My template|one|two|hello|world|three}}), splicing becomes the way to go (in this case ...|splicing|add_last_of_sequence|0|2|2|hello|world|...).

The add to position optional flag argument can either be add_nothing, add_smallest_number, add_last_of_sequence, or add_largest_number. When omitted it defaults to add_nothing. These numbers refer to the array as it was before being resized, and the chosen number will be summed to the position argument.

The position and increment arguments can be zero or positive or negative numbers. When increment is positive the array of numeric parameters will be increased, when it is negative it will be decreased and one or more parameters will be removed.

The optional argument number of elements to write indicates how many parameters must be written in the given position. It must be followed by an equal number of arguments. When omitted it defaults to 0. If this number is larger than increment the pre-existing parameters in excess will be overwritten, if it is minor instead the missing parameters will be left undefined.

For instance, imagining a template transcluded as,

{{My template|-3=minus three|-2=minus two|-1=minus one|0=zero|one|two|three|15=fifteen}}

and extrapolating the following constants,

smallest number = −3
last of sequence = 3
largest number = 15

the following table summarizes how the incoming parameters are manipulated by splicing.

Use of `splicing`	Computed position	Result
`...\|splicing\|4\|2\|2\|hello\|world\|...`	`4` + nothing = 4	-3→minus three; -2→minus two; -1→minus one; 0→zero; 1→one; 2→two; 3→three; 4→hello; 5→world; 17→fifteen
`...\|splicing\|add_last_of_sequence\|1\|2\|2\|hello\|world\|...`	`1` + last of sequence = 4	-3→minus three; -2→minus two; -1→minus one; 0→zero; 1→one; 2→two; 3→three; 4→hello; 5→world; 17→fifteen
`...\|splicing\|add_smallest_number\|-2\|2\|2\|hello\|world\|...`	`-2` + smallest number = −5	-5→hello; -4→world; -3→minus three; -2→minus two; -1→minus one; 0→zero; 1→one; 2→two; 3→three; 15→fifteen
`...\|splicing\|add_largest_number\|-2\|100\|2\|hello\|world\|...`	`-2` + largest number = 13	-3→minus three; -2→minus two; -1→minus one; 0→zero; 1→one; 2→two; 3→three; 13→hello; 14→world; 115→fifteen
`...\|splicing\|add_nothing\|1\|0\|1\|hello\|...`	`1` + nothing = 1	-3→minus three; -2→minus two; -1→minus one; 0→zero; 1→hello; 2→two; 3→three; 15→fifteen
`...\|splicing\|add_nothing\|1\|-1\|1\|hello\|...`	`1` + nothing = 1	-3→minus three; -2→minus two; -1→minus one; 0→zero; 1→hello; 2→three; 14→fifteen
`...\|splicing\|1\|-1\|...` or `...\|splicing\|1\|-1\|0\|...`	`1` + nothing = 1	-3→minus three; -2→minus two; -1→minus one; 0→zero; 1→two; 2→three; 14→fifteen

Note: The values of the parameters inserted will not be trimmed of their leading and trailing spaces. The arguments add to position, position, length and how many and the splicing modifier name itself, instead, will be trimmed of their surrounding spaces.

`imposing`

Modifier `imposing` (code)
See also
Num. of arguments	2
Repeatable	Yes
`providing`, `discarding`, `splicing`, `filling_the_gaps`, `new`

Brief: Impose a new value to a pre-existing parameter or create a new parameter
Syntax: {{#invoke:params|imposing|name|value|pipe function name}}

Example:

{{#invoke:params|imposing|foo|bar|imposing|hello|world|for_each|[$#: $@]}}

Note: The value assigned will not be trimmed of its leading and trailing spaces. The name of the parameter and the imposing modifier name itself, instead, will be trimmed of their surrounding spaces.

`providing`

Modifier `providing` (code)
See also
Num. of arguments	2
Repeatable	Yes
`imposing`, `discarding`, `splicing`, `filling_the_gaps`, `new`

Brief: Assign a new value to a parameter, but only when missing, otherwise keep the previous value
Syntax: {{#invoke:params|providing|name|value|pipe function name}}

Example:

{{#invoke:params|providing|foo|bar|providing|hello|world|for_each|[$#: $@]}}

Note: The value assigned will not be trimmed of its leading and trailing spaces. The name of the parameter and the providing modifier name itself, instead, will be trimmed of their surrounding spaces.

`discarding`

Modifier `discarding` (code)
See also
Num. of arguments	1 or 2
Repeatable	Yes
`clearing`, `cutting`, `cropping`, `purging`, `backpurging`, `splicing`, `new`

Brief: Discard one or more numeric parameters or one non-numeric parameter
Syntax: {{#invoke:params|discarding|name|[how many]|pipe function name}}

If, and only if, the name of the parameter is numeric, it is possible to add a second argument to indicate how many contiguous parameters must be discarded starting from the first argument. If the discarded parameters is part of the parameters' sequence one or more holes will be created. To avoid creating holes, use purging or backpurging or shifting.

Example #1 (discard the parameter named |hello=):

{{#invoke:params|discarding|hello|for_each|[$#: $@]}}

Example #2 (discard the parameter named |5=):

{{#invoke:params|discarding|5|for_each|[$#: $@]}}

Example #3 (discard the parameters named |1=, |2=, |3= and |4=):

{{#invoke:params|discarding|1|4|for_each|[$#: $@]}}

It is possible to use this modifier to check for unknown parameters:

{{#ifexpr:{{#invoke:params|discarding|hello|discarding|wind|count}} > 0
	| {{Error|Error: The only parameters accepted are {{para|hello}} and {{para|wind}}.}}
	| Everything is good: do something
}}

You can find this example at {{./doc/examples/check for unknown parameters}}. For instance, {{module:params/doc/examples/check for unknown parameters|hello=world|wind=surfing}} will generate

Everything is good: do something

For simple cases like this, however, dedicated modules are available; you might want to have a look at:

{{#invoke:Check for unknown parameters|check}}
{{#invoke:Check for deprecated parameters|check}}
{{#invoke:Check for clobbered parameters|check}}
{{#invoke:Parameter validation|validateparams}}
{{#invoke:TemplatePar|valid}}

When used to discard single parameters, this modifier is equivalent to writing ...|with_name_not_matching|parameter name|strict|.... However, due to the fact that with_name_not_matching needs to cross-check for the possible presence of or keywords, using discarding will be slightly more efficient.

Note: All arguments passed to this modifier and the discarding modifier name itself will be trimmed of their surrounding spaces.

`excluding_non-numeric_names`

Modifier `excluding_non-numeric_names` (code)
See also
Num. of arguments	0
Repeatable	Yes
`excluding_non-numeric_names`, `with_name_matching`, `with_name_not_matching`, `clearing`

Brief: Discard all non-numeric parameters
Syntax: {{#invoke:params|excluding_non-numeric_names|pipe function name}}

This modifier is only syntax sugar for ...|with_name_matching|^%-?%d+$|... (but using a slighly faster optimization). For the inverse modifier, see excluding_numeric_names. If you want to remove also non-sequential parameters, add the clearing modifier to the pipeline (...|excluding_non-numeric_names|clearing|...).

`excluding_numeric_names`

Modifier `excluding_numeric_names` (code)
See also
Num. of arguments	0
Repeatable	Yes
`excluding_non-numeric_names`, `with_name_matching`, `with_name_not_matching`

Brief: Discard all numeric parameters (not only the sequential ones)
Syntax: {{#invoke:params|excluding_numeric_names|pipe function name}}

This modifier is only syntax sugar for ...|with_name_not_matching|^%-?%d+$|... (but using a slighly faster optimization). For the inverse modifier, see excluding_non-numeric_names.

`with_name_matching`

Modifier `with_name_matching` (code)
See also
Num. of arguments	Ad libitum
Repeatable	Yes
`excluding_numeric_names`, `excluding_non-numeric_names`, `with_name_not_matching`, `with_value_matching`, `with_value_not_matching`

Brief: Discard all parameters whose name does not match any of the given patterns
Syntax: {{#invoke:params|with_name_matching|target 1|[plain flag 1]|[or]|[target 2]|[plain flag 2]|[or]|[...]|[target N]|[plain flag N]|pipe function name}}

Internally this modifier uses Lua's string.find() function to find whether parameter names match against given patterns; therefore, unless a plain flag is set, please use the same syntax of Lua patterns. The plain flag can be either plain or strict or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between plain and strict is that the latter also requires that the lengths match (this happens only when the two strings are 100% identical). In order to facilitate wikitext scripting in the plain flag argument, the pattern keyword is available too, equivalent to omitting the argument.

To express a logical OR the or keyword is available. To express a logical AND instead, concatenate more invocations of with_name_matching.

For the sake of argument we will imagine that we are invoking with_name_matching from within the {{Infobox artery}} template, and this is being called with the following parameters:

{{Infobox artery
	| Name = Pulmonary artery
	| Latin = truncus pulmonalis, arteria pulmonalis
	| Image = {{Heart diagram 250px}}
	| Caption = Anterior (frontal) view of the opened heart. (Pulmonary artery upper right.)
	| Image2 = Alveoli diagram.png
	| Caption2 = Diagram of the alveoli with both cross-section and external view.
	| BranchFrom = [[right ventricle]]
	| BranchTo = 
	| Vein = [[pulmonary vein]]
	| Precursor = truncus arteriosus
	| Supplies = 
}}

Test cases:

List only the parameters whose names match against the ^Image pattern:
↳ {{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_matching|^Image|list}}
↳ |Image={{Heart diagram 250px}}|Image2=Alveoli diagram.png
List the parameters whose names match against both patterns ^Image and %d+$:
↳ {{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_matching|^Image|with_name_matching|%d+$|list}}
↳ |Image2=Alveoli diagram.png
List the parameters whose names match against either the ^Name or the ^Latin$ pattern:
↳ {{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_matching|^Name$|or|^Latin$|list}}
↳ |Latin=truncus pulmonalis, arteria pulmonalis|Name=Pulmonary artery
List the parameters whose names match against either the ma plain string or the me$ pattern:
↳ {{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_matching|ma|plain|or|me$|list}}
↳ |Image={{Heart diagram 250px}}|Name=Pulmonary artery|Image2=Alveoli diagram.png

Using with_name_matching it is easy to emulate the behaviour of Module:Enumerate (or similar modules). For instance, the following examples creates a bullet list of all the parameters passed of type |foobar1, |foobar2 … |foobarN:

{{#invoke:params|all_sorted|with_name_matching|^foobar%d+$|setting|ih|
* |list_values}}

It is possible to see this example live at {{./doc/examples/enumerate}}.

Note: The target arguments passed to this modifier will not be trimmed of their leading and trailing spaces. The or, plain, strict and pattern keywords, and the with_name_matching modifier name itself, instead, will be trimmed of their surrounding spaces.

`with_name_not_matching`

Modifier `with_name_not_matching` (code)
See also
Num. of arguments	Ad libitum
Repeatable	Yes
`excluding_numeric_names`, `excluding_non-numeric_names`,`with_name_matching`, `with_value_matching`, `with_value_not_matching`

Brief: Discard all parameters whose name matches all the given patterns
Syntax: {{#invoke:params|with_name_not_matching|target 1|[plain flag 1]|[and]|[target 2]|[plain flag 2]|[and]|[...]|[target N]|[plain flag N]|pipe function name}}

Internally this modifier uses Lua's string.find() function to find whether parameter names match against given patterns; therefore, unless a plain flag is set, please use the same syntax of Lua patterns. The plain flag can be either plain or strict or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between plain and strict is that the latter also requires that the lengths match (this happens only when the two strings are 100% identical). In order to facilitate wikitext scripting in the plain flag argument, the pattern keyword is available too, equivalent to omitting the argument.

To express a logical OR the or keyword is available. To express a logical AND instead, concatenate more invocations of with_name_not_matching.

For the sake of argument we will imagine that we are invoking with_name_not_matching from within the {{Infobox artery}} template, and this is being transcluded using the same parameters that we had imagined in the previous example at with_name_matching:

List only the parameters whose names do not match against the a pattern:
{{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_not_matching|a|list}}
↳ |Precursor=truncus arteriosus|Supplies=|Vein=pulmonary vein
List the parameters whose names do not match against the a plain string and do not match against the l plain string either:
{{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_not_matching|a|plain|with_name_not_matching|l|plain|list}}
↳ |Precursor=truncus arteriosus|Vein=pulmonary vein
List the parameters whose names do not match against either the a plain string or the n plain string:
{{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_not_matching|a|plain|or|n|plain|list}}
↳ |Precursor=truncus arteriosus|Supplies=|Image={{Heart diagram 250px}}|Name=Pulmonary artery|Image2=Alveoli diagram.png|Vein=pulmonary vein

* For the sake of efficiency, please don't use this modifier with the strict flag unless accompanied by or, use discarding instead!

Note: The target arguments passed to this modifier will not be trimmed of their leading and trailing spaces. The or, plain, strict and pattern keywords, and the with_name_not_matching modifier name itself, instead, will be trimmed of their surrounding spaces.

`with_value_matching`

Modifier `with_value_matching` (code)
See also
Num. of arguments	Ad libitum
Repeatable	Yes
`with_name_matching`, `with_name_not_matching`, `with_value_not_matching`

Brief: Discard all parameters whose value does not match any of the given patterns
Syntax: {{#invoke:params|with_value_matching|target 1|[plain flag 1]|[or]|[target 2]|[plain flag 2]|[or]|[...]|[target N]|[plain flag N]|pipe function name}}

Exactly like with_name_matching, but applied to parameter values instead of names.

Internally this modifier uses Lua's string.find() function to find whether parameter names match against given patterns; therefore, unless a plain flag is set, please use the same syntax of Lua patterns. The plain flag can be either plain or strict or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between plain and strict is that the latter also requires that the lengths match (this happens only when the two strings are 100% identical). In order to facilitate wikitext scripting in the plain flag argument, the pattern keyword is available too, equivalent to omitting the argument.

Example:

{{#invoke:params|with_value_matching|banana|count}}

Note: The target arguments passed to this modifier will not be trimmed of their leading and trailing spaces. The or, plain, strict and pattern keywords, and the with_value_matching modifier name itself, instead, will be trimmed of their surrounding spaces.

`with_value_not_matching`

Modifier `with_value_not_matching` (code)
See also
Num. of arguments	Ad libitum
Repeatable	Yes
`with_name_matching`, `with_name_not_matching`, `with_value_matching`

Brief: Discard all parameters whose value matches all the given patterns
Syntax: {{#invoke:params|with_value_not_matching|target 1|[plain flag 1]|[and]|[target 2]|[plain flag 2]|[and]|[...]|[target N]|[plain flag N]|pipe function name}}

Exactly like with_name_not_matching, but applied to parameter values instead of names.

Internally this modifier uses Lua's string.find() function to find whether parameter names match against given patterns; therefore, unless a plain flag is set, please use the same syntax of Lua patterns. The plain flag can be either plain or strict or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between plain and strict is that the latter also requires that the lengths match (this happens only when the two strings are 100% identical). In order to facilitate wikitext scripting in the plain flag argument, the pattern keyword is available too, equivalent to omitting the argument.

For instance, before calling list, the following code will get rid of all blank parameters (i.e. parameters whose values contain only zero or more spaces):

{{#invoke:params|with_value_not_matching|^%s*$|setting|hi/p|{{!}}|{{=}}|list}}

A typical use case of this modifier is that of purging all empty incoming parameters before calling another template, especially when this distinguishes between empty and undefined parameters.

{{#invoke:params|with_value_not_matching|^%s*$|concat_and_call|my template}}

Note: The target arguments passed to this modifier will not be trimmed of their leading and trailing spaces. The or, plain, strict and pattern keywords, and the with_value_not_matching modifier name itself, instead, will be trimmed of their surrounding spaces.

`trimming_values`

Modifier `trimming_values` (code)
Num. of arguments	0
Repeatable	Yes

Brief: Remove leading and trailing spaces from values
Syntax: {{#invoke:params|trimming_values|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

Most modifiers are order-dependent, therefore placing trimming_values in different positions can generate different results. For instance, imagining our {{example template}} being called with the following spaced arguments: {{example template| wanna | be | my | friend | ? }}. If {{example template}} contained the following code,

{{#invoke:params|with_value_matching|%s+$|trimming_values|setting|i/p|{{!}}|{{=}}|list}}

the following text would be printed: 1=wanna|2=be|3=my|4=friend|5=?. But if instead it contained the following code,

{{#invoke:params|trimming_values|with_value_matching|%s+$|setting|i/p|{{!}}|{{=}}|list}}

no arguments would be shown.

Order affects also performance, and how many values will be trimmed of their leading and trailing spaces will depend on where trimming_values is placed. For instance, if a template were invoked with 50 parameters and its code contained {{#invoke:params|trimming_values|cutting|-1|0|list}}, first all its values would be trimmed of leading and trailing blank spaces and then its first 49 parameters would be discarded. On the other hand, writing {{#invoke:params|cutting|-1|0|trimming_values|list}} would first discard 49 parameters and then trim the only value left, resulting in a more efficient code. As a general rule, placing trimming_values as the last modifier is usually the best choice.

In most cases placing trimming_values together with non-sequential will result in an empty call with no effects, because non-sequential parameters are normally stripped of their leading and trailing spaces by default – this however depends on the caller, and if the current template is being called by a module it is in theory possible in specific conditions for named parameters to retain their leading and trailing spaces (namely in non-sequential numeric parameters).

Using trimming_values makes this module behave like other Wikipedia modules behave. For example, if we wanted to emulate {{#invoke:Separated entries|main}}, writing

{{#invoke:params|sequential|trimming_values|with_value_not_matching||strict|squeezing|setting|i|XXXX|list_values}}

will be equivalent to writing,

{{#invoke:separated entries|main|separator=XXXX}}

whereas writing

{{#invoke:params|sequential|trimming_values|with_value_not_matching||strict|squeezing|setting|i/l|XXXX|YYYY|list_values}}

will be equivalent to writing

{{#invoke:separated entries|main|separator=XXXX|conjunction=YYYY}}

The {{./doc/examples/trim and call}} example template shows how to call any arbitrary template trimming all parameters beforehand.

`mapping_to_lowercase`

Modifier `mapping_to_lowercase` (code)
See also
Num. of arguments	0
Repeatable	Yes
`mapping_to_uppercase`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `mapping_by_replacing`, `renaming_by_replacing`

Brief: Convert all parameter values to lower case
Syntax: {{#invoke:params|mapping_to_lowercase|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This modifier converts all parameter values to lower case. It is identical to writing ...|mapping_by_magic|lc|..., but without the burden of calling a parser function.

`mapping_to_uppercase`

Modifier `mapping_to_uppercase` (code)
See also
Num. of arguments	0
Repeatable	Yes
`mapping_to_lowercase`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `mapping_by_replacing`, `renaming_by_replacing`

Brief: Convert all parameter values to upper case
Syntax: {{#invoke:params|mapping_to_uppercase|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This modifier converts all parameter values to upper case. It is identical to writing ...|mapping_by_magic|uc|..., but without the burden of calling a parser function.

`mapping_by_calling`

Modifier `mapping_by_calling` (code)
See also
Num. of arguments	Ad libitum
Repeatable	Yes
`mapping_to_lowercase`, `mapping_to_uppercase`, `call_for_each`, `call_for_each_value`, `mapping_by_invoking`, `mapping_by_magic`, `mapping_by_replacing`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_invoking`, `renaming_by_magic`, `renaming_by_replacing`, `grouping_by_calling`

Brief: Map all parameter values, replacing their content with the expansion of a given template repeatedly called with one parameter (the parameter's value)
Syntax: {{#invoke:params|mapping_by_calling|template name|[call style]|[let]|[...]|[number of additional parameters]|[parameter 1]|[parameter 2]|[...]|[parameter N]|pipe function name}}

This modifier (temporarily) changes the content of the parameters the current template is being called with, replacing each of them with the text returned by another template. The latter will be repeatedly called with at least one parameter as first sequential parameter: the parameter's value.

It is possible to pass the parameter's value as a different parameter, or pass the parameter's name as well, by specifying a call style flag immediately after the template name (see below).

If the call style flag or (if omitted) the template name is followed by one or more groups of three arguments led by the let keyword (i.e. let|name|value), these will be passed to the mapping template.

If the last group of three arguments or (if omitted) the call style flag or (if omitted) the template name is followed by a number, this will be parsed as the amount of positional parameters to add. These will always follow the current parameter's name and/or value if any of the latter are passed using a numeric name greater than zero.

In case of collisions, the parameters assigned via the let keyword will be given precedence over everything else.

For instance, before listing all parameters,

{{#invoke:params|mapping_by_calling|foobar|setting|i/p|{{!}}|{{=}}|list}}

will replace each value with the expansion of {{foobar|VALUE}} (where VALUE indicates each different value).

On the other hand,

{{#invoke:params|mapping_by_calling|foobar|names_and_values|let|rice|nope|let|curry|lots!|2|hello|world|setting|i/p|{{!}}|{{=}}|list}}

will do the same, but using the expansion of {{foobar|NAME|VALUE|hello|world|rice=nope|curry=lots!}} (where NAME and VALUE indicate each different name and value).

Possible call style flags are:

Call style flag	Example	Corresponding call
`names_and_values`	`{{#invoke:params\|mapping_by_calling\|example template\|names_and_values\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|NAME\|VALUE\|hello\|world\|foo=bar}}`
`values_and_names`	`{{#invoke:params\|mapping_by_calling\|example template\|values_and_names\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|VALUE\|NAME\|hello\|world\|foo=bar}}`
`names_only`	`{{#invoke:params\|mapping_by_calling\|example template\|names_only\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|NAME\|hello\|world\|foo=bar}}`
`values_only`	`{{#invoke:params\|mapping_by_calling\|example template\|values_only\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|VALUE\|hello\|world\|foo=bar}}`
`names_and_values_as\|...\|...`	`{{#invoke:params\|mapping_by_calling\|example template\|names_and_values_as\|my_name\|my_value\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|hello\|world\|my_name=NAME\|my_value=VALUE\|foo=bar}}`
`names_only_as\|...`	`{{#invoke:params\|mapping_by_calling\|example template\|names_only_as\|my_name\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|hello\|world\|my_name=NAME\|foo=bar}}`
`values_only_as\|...`	`{{#invoke:params\|mapping_by_calling\|example template\|values_only_as\|my_value\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|hello\|world\|my_value=VALUE\|foo=bar}}`
`blindly`	`{{#invoke:params\|mapping_by_calling\|example template\|blindly\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|hello\|world\|foo=bar}}`

If the call style flags argument is omitted it defaults to values_only.

Note: All arguments passed to this modifier except the mapping_by_calling modifier name itself, the template name, the call style flag, the let keyword, the passed parameter names, and the number of additional parameters will not be trimmed of their leading and trailing spaces.

`mapping_by_invoking`

Modifier `mapping_by_invoking` (code)
See also
Num. of arguments	Ad libitum
Repeatable	Yes
`mapping_to_lowercase`, `mapping_to_uppercase`, `invoke_for_each`, `invoke_for_each_value`, `mapping_by_calling`, `mapping_by_magic`, `mapping_by_replacing`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_invoking`, `renaming_by_magic`, `renaming_by_replacing`, `grouping_by_calling`

Brief: Map all parameter values, replacing their content with the text returned by a given module function repeatedly invoked with at least one argument (the parameter's value)
Syntax: {{#invoke:params|mapping_by_invoking|module name|function name|[call style]|[let]|[...]|[number of additional arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe function name}}

This modifier (temporarily) changes the content of the parameters the current template is being called with, replacing each of them with the text returned by a custom module function. The latter will be repeatedly called with at least one argument as first sequential argument: the parameter's value.

It is possible to pass the parameter's value as a different argument, or pass the parameter's name as well, by specifying a call style flag immediately after the function name (see mapping_by_calling for the list of possible flags). If omitted, the call style flags argument defaults to values_only.

If the call style flag or (if omitted) the function name is followed by one or more groups of three arguments led by the let keyword (i.e. let|name|value), these will be passed to the mapping module function.

If the last group of three arguments or (if omitted) the call style flag or (if omitted) the function name is followed by a number, this will be parsed as the amount of positional parameters to add. These will always follow the current parameter's name and/or value if any of the latter are passed using a numeric name greater than zero.

In case of collisions, the arguments assigned via the let keyword will be given precedence over everything else.

For instance, before listing all parameters,

{{#invoke:params|mapping_by_invoking|foobar|main|setting|i/p|{{!}}|{{=}}|list}}

will replace each value with the expansion of {{#invoke:foobar|main|VALUE}} (where VALUE indicates each different value).

On the other hand,

{{#invoke:params|mapping_by_invoking|foobar|main|names_and_values|let|rice|nope|let|curry|lots!|2|hello|world|setting|i/p|{{!}}|{{=}}|list}}

will do the same, but using the expansion of {{#invoke:foobar|main|NAME|VALUE|hello|world|rice=nope|curry=lots!}} (where NAME and VALUE indicate each different name and value).

Note: All arguments passed to this modifier except the mapping_by_invoking modifier name itself, the module name, the function name, the call style flag, the let keyword, the passed parameter names, and the number of additional arguments will not be trimmed of their leading and trailing spaces.

`mapping_by_magic`

Modifier `mapping_by_magic` (code)
See also
Num. of arguments	Ad libitum
Repeatable	Yes
`mapping_to_lowercase`, `mapping_to_uppercase`, `magic_for_each`, `magic_for_each_value`, `mapping_by_calling`, `mapping_by_invoking`, `mapping_by_replacing`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_invoking`, `renaming_by_magic`, `renaming_by_replacing`, `grouping_by_calling`

Brief: Map all parameter values, replacing their content with the expansion of a given parser function repeatedly called with at least one argument (the parameter's value)
Syntax: {{#invoke:params|mapping_by_magic|parser function|[call style]|[let]|[...]|[number of additional arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe function name}}

This modifier (temporarily) changes the content of the parameters the current template is being called with, replacing each of them with the text returned by a parser function. The latter will be repeatedly called with at least one argument as first sequential argument: the parameter's value.

It is possible to pass the parameter's value as a different argument, or pass the parameter's name as well, by specifying a call style flag immediately after the parser function name (see mapping_by_calling for the list of possible flags). If omitted, the call style flags argument defaults to values_only.

If the call style flag or (if omitted) the template name is followed by one or more groups of three arguments led by the let keyword (i.e. let|name|value), these will be passed to the parser function.

If the last group of three arguments or (if omitted) the call style flag or (if omitted) the template name is followed by a number, this will be parsed as the amount of positional arguments to add. These will always follow the current parameter's name and/or value if any of the latter are passed using a numeric name greater than zero.

In case of collisions, the arguments assigned via the let keyword will be given precedence over everything else.

For instance, before listing all parameters,

{{#invoke:params|mapping_by_magic|uc|setting|i/p|{{!}}|{{=}}|list}}

will replace each value with the expansion of {{uc:VALUE}} (where VALUE indicates each different value).

On the other hand,

{{#invoke:params|mapping_by_magic|plural|names_and_values|1|They are many|setting|i/p|{{!}}|{{=}}|list}}

will do the same, but using the expansion of {{plural:NAME|VALUE|They are many}} (where NAME and VALUE indicate each different name and value).

Note: All arguments passed to this modifier except the mapping_by_magic modifier name itself, the parser function's name, the call style flag, the let keyword, the passed parameter names, and the number of additional arguments will not be trimmed of their leading and trailing spaces.

`mapping_by_replacing`

Modifier `mapping_by_replacing` (code)
See also
Num. of arguments	2–4
Repeatable	Yes
`mapping_by_mixing`, `mapping_to_lowercase`, `mapping_to_uppercase`, `mapping_by_calling`, `mapping_by_invoking`, `mapping_by_magic`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_invoking`, `renaming_by_magic`, `renaming_by_replacing`, `renaming_by_mixing`, `grouping_by_calling`, `mixing_names_and_values`

Brief: Map all parameter values performing string substitutions
Syntax: {{#invoke:params|mapping_by_replacing|target|replace|[count]|[plain flag]|pipe function name}}

This modifier (temporarily) changes the content of the parameters the current template is being called with, replacing each of them with the result of a string substitution. Its syntax is very simlar to {{#invoke:string|replace}}.

Internally the modifier uses Lua's string.gsub() function to perform substitutions; therefore, unless a plain flag is set, please use the same syntax of Lua patterns. The plain flag can be either plain or strict or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between plain and strict is that the latter also requires that the lengths match (this happens only when the two strings are 100% identical). In strict mode the replace argument will not accept directives (e.g. %0, %1, etc.). In order to facilitate wikitext scripting in the plain flag argument, the pattern keyword is available too, equivalent to omitting the argument.

The count argument prescribes how many substitutions will be performed at most. If blank or omitted, all matches found will be substituted.

This modifier uses string.gsub() for performance reasons; if you need to use mw.ustring.gsub() instead, you will need to invoke the replace function from Module:String via ...|mapping_by_invoking|string|replace|....

The following table shows examples of equivalent instructions. Please be aware that invoking mw.ustring.gsub() can be much slower.

`string.gsub()`	`mw.ustring.gsub()` (via Module:String)
`...\|mapping_by_replacing\|target\|replace\|...`	`...\|mapping_by_invoking\|string\|replace\|4\|target\|replace\|\|false\|...`
`...\|mapping_by_replacing\|target\|replace\|count\|...`	`...\|mapping_by_invoking\|string\|replace\|4\|target\|replace\|count\|false\|...`
`...\|mapping_by_replacing\|target\|replace\|plain\|...`	`...\|mapping_by_invoking\|string\|replace\|2\|target\|replace\|...` or, equivalently, `...\|mapping_by_invoking\|string\|replace\|4\|target\|replace\|\|true\|...`
`...\|mapping_by_replacing\|target\|replace\|count\|plain\|...`	`...\|mapping_by_invoking\|string\|replace\|3\|target\|replace\|count\|...` or, equivalently, `...\|mapping_by_invoking\|string\|replace\|4\|target\|replace\|count\|true\|...`

There is not a corresponding translation for the strict flag in Module:String. However, as it goes with the plain flag, in that case you won't need mw.ustring.gsub() in the first place.

For example,

...|mapping_by_renaming|foo|bar|1|...

will be equivalent to writing

...|mapping_by_invoking|string|replace|4|foo|bar|1|false|...

The first syntax, however, will be less computationally expensive.

At {{./doc/examples/informal tablebox}} you can find an example on how to exploit this function to create "informal" infoboxes.

Note: The target and replace arguments passed to this modifier will not be trimmed of their leading and trailing spaces. The or, plain, strict and pattern keywords, the count argument, and the mapping_by_replacing modifier name itself, instead, will be trimmed of their surrounding spaces.

`mapping_by_mixing`

Modifier `mapping_by_mixing` (code)
See also
Num. of arguments	1
Repeatable	Yes
`mapping_to_lowercase`, `mapping_to_uppercase`, `mapping_by_calling`, `mapping_by_invoking`, `mapping_by_magic`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_invoking`, `renaming_by_magic`, `renaming_by_replacing`, `renaming_by_mixing`, `grouping_by_calling`, `mixing_names_and_values`

Brief: Map all parameter values replacing their current values with the expansion of a custom string containing the $# and $@ placeholders
Syntax: {{#invoke:params|mapping_by_mixing|mixing string|pipe function name}}

This modifier (temporarily) changes the content of the parameters the current template is being called with, replacing each of them with the expansion of a custom string that expects the same syntax as the for_each function.

For instance, the following code will wrap all parameter values in quotes

...|mapping_by_mixing|"$@"|...

whereas the following code will replace all values with the string [NAME::VALUE], where NAME and VALUE are each parameter's name and value:

...|mapping_by_mixing|[$#::$@]|...

Note: The mixing string argument passed to this modifier will not be trimmed of its leading and trailing spaces. The mapping_by_mixing modifier name itself, instead, will be trimmed of its surrounding spaces.

`renaming_to_lowercase`

Modifier `renaming_to_lowercase` (code)
See also
Num. of arguments	0
Repeatable	Yes
`mapping_to_lowercase`, `mapping_to_uppercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `mapping_by_replacing`, `renaming_by_replacing`

Brief: Convert all parameter names to lower case
Syntax: {{#invoke:params|renaming_to_lowercase|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This modifier converts all parameter names to lower case. It is identical to writing ...|renaming_by_magic|lc|..., but without the burden of calling a parser function.

Note: In case of collisions between identical names, only one parameter, randomly chosen, will be left for a given name.

`renaming_to_uppercase`

Modifier `renaming_to_uppercase` (code)
See also
Num. of arguments	0
Repeatable	Yes
`mapping_to_lowercase`, `mapping_to_uppercase`, `renaming_to_lowercase`, `renaming_to_sequence`, `mapping_by_replacing`, `renaming_by_replacing`

Brief: Convert all parameter names to upper case
Syntax: {{#invoke:params|renaming_to_uppercase|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This modifier converts all parameter names to upper case. It is identical to writing ...|renaming_by_magic|uc|..., but without the burden of calling a parser function.

Note: In case of collisions between identical names, only one parameter, randomly chosen, will be left for a given name.

`renaming_to_sequence`

Modifier `renaming_to_sequence` (code)
See also
Num. of arguments	0–1 (variable)
Repeatable	Yes
`mapping_to_lowercase`, `mapping_to_uppercase`, `mapping_by_calling`, `mapping_by_invoking`, `mapping_by_magic`, `mapping_by_replacing`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_invoking`, `renaming_by_magic`, `renaming_by_replacing`, `grouping_by_calling`

Brief: Rename all parameter names using sequential integers and possibly following a sort order
Syntax: {{#invoke:params|renaming_to_sequence|[sort order]|pipe function name}}

This modifier renames all parameter names using increasing sequential integers, possibly following a given sort order.

The sort order optional flag specifies what sort order must be followed. Possible values are alphabetically, naturally (for natural sort order) and without_sorting. When omitted it defaults to without_sorting.

Wikitext:

{{#invoke:params|new|
	imposing|zebra|window|
	imposing|foo|bar|
	imposing|hello|world|
	renaming_to_sequence|naturally|
	setting|i/p|<br />|: |
	list
}}

Effect:

1: bar
2: world
3: window

Wikitext:

{{#invoke:params|new|
	imposing|zebra|window|
	imposing|foo|bar|
	imposing|hello|world|
	renaming_to_sequence|
	setting|i/p|<br />|: |
	list
}}

Effect:

1: world
2: window
3: bar

Note: The renaming_to_sequence modifier name and the sort order argument will be trimmed of their surrounding spaces.

`renaming_by_calling`

Modifier `renaming_by_calling` (code)
See also
Num. of arguments	Ad libitum
Repeatable	Yes
`mapping_to_lowercase`, `mapping_to_uppercase`, `mapping_by_calling`, `mapping_by_invoking`, `mapping_by_magic`, `mapping_by_replacing`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_invoking`, `renaming_by_magic`, `renaming_by_replacing`, `grouping_by_calling`

Brief: Rename all parameters, replacing their former names with the expansion of a given template repeatedly called with at least one parameter (the parameter's former name)
Syntax: {{#invoke:params|renaming_by_calling|template name|[call style]|[let]|[...]|[number of additional parameters]|[parameter 1]|[parameter 2]|[...]|[parameter N]|pipe function name}}

This modifier works similarly to mapping_by_calling, but instead of replacing parameters' values it renames the parameters themselves. Care must be used knowing that if a new name collides with another new name one of the two parameters will be removed without knowing which one. New names and old names do not create collisions. If a name is returned identical it will be considered as "unchanged" and in case of conflicts the renamed one will prevail. Possible leading and trailing spaces in the new names are always stripped. Here, if omitted, the call style flags argument defaults to names_only.

For instance, the following example uses {{2x}} to rename all incoming parameters by doubling their names:

{{#invoke:params|setting|h/i/p/f|[|][|: |]|renaming_by_calling|2x|list}}

Same, but adding a hyphen in between:

{{#invoke:params|setting|h/i/p/f|[|][|: |]|renaming_by_calling|2x|1|-|list}}

The following example calls the {{P1}} template to rename all parameters using their value as their new name:

{{#invoke:params|renaming_by_calling|P1|values_only|for_each|[$#: $@]}}

This modifier can be particularly useful for sanitizing parameter names (e.g. collapsing several spaces into single spaces, changing the letter case, and so on).

Note: All arguments passed to this modifier except the renaming_by_calling modifier name itself, the template name, the call style flag, the let keyword, the passed parameter names, and the number of additional arguments will not be trimmed of their leading and trailing spaces.

`renaming_by_invoking`

Modifier `renaming_by_invoking` (code)
See also
Num. of arguments	Ad libitum
Repeatable	Yes
`mapping_to_lowercase`, `mapping_to_uppercase`, `mapping_by_calling`, `mapping_by_invoking`, `mapping_by_magic`, `mapping_by_replacing`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_magic`, `renaming_by_replacing`, `grouping_by_calling`

Brief: Rename all parameters, replacing their former names with the text returned by a given module function repeatedly called with at least one argument (the parameter's former name)
Syntax: {{#invoke:params|renaming_by_invoking|module name|function name|[call style]|[let]|[...]|[number of additional arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe function name}}

This modifier works similarly to mapping_by_invoking, but instead of replacing parameters' values it renames the parameters themselves. Care must be used knowing that if a new name collides with another new name one of the two parameters will be removed without knowing which one. New names and old names do not create collisions. If a name is returned identical it will be considered as "unchanged" and in case of conflicts the renamed one will prevail. Possible leading and trailing spaces in the new names are always stripped. Here, if omitted, the call style flags argument defaults to names_only.

For instance, the following example uses {{#invoke:string|rep}} to rename all parameters of type |a=, |b=, … |z= into |aaa=, |bbb= … |zzz=:

{{#invoke:params|setting|h/i/p/f|[|][|: |]|with_name_matching|^%a$|renaming_by_invoking|string|rep|1|3|list}}

Note: All arguments passed to this modifier except the renaming_by_invoking modifier name itself, the module name, the function name, the call style flag, the let keyword, the passed parameter names, and the number of additional arguments will not be trimmed of their leading and trailing spaces.

`renaming_by_magic`

Modifier `renaming_by_magic` (code)
See also
Num. of arguments	Ad libitum
Repeatable	Yes
`mapping_to_lowercase`, `mapping_to_uppercase`, `mapping_by_calling`, `mapping_by_invoking`, `mapping_by_magic`, `mapping_by_replacing`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_invoking`, `renaming_by_replacing`, `grouping_by_calling`

Brief: Rename all parameters, replacing their former names with the text returned by a given parser function repeatedly called with at least one argument (the parameter's former name)
Syntax: {{#invoke:params|renaming_by_magic|parser function|[call style]|[let]|[...]|[number of additional arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe function name}}

This modifier works similarly to mapping_by_magic, but instead of replacing parameters' values it renames the parameters themselves. Care must be used knowing that if a new name collides with another new name one of the two parameters will be removed without knowing which one. New names and old names do not create collisions. If a name is returned identical it will be considered as "unchanged" and in case of conflicts the renamed one will prevail. Possible leading and trailing spaces in the new names are always stripped. Here, if omitted, the call style flags argument defaults to names_only.

For instance, the following example uses {{#expr}} to transform all numeric parameters into even numbers (you can replace the expression %0 * 2 with any other expression):

{{#invoke:params|all_sorted|excluding_non-numeric_names|renaming_by_replacing|^.*$|%0 * 2|1|renaming_by_magic|#expr|setting|h/i/p/f|[|][|: |]|list}}

An example that uses this function with the {{REVISIONTIMESTAMP}} magic word is available at {{./doc/examples/watchlist}}.

Note: All arguments passed to this modifier except the renaming_by_magic modifier name itself, the parser function name, the call style flag, the let keyword, the passed parameter names, and the number of additional arguments will not be trimmed of their leading and trailing spaces.

`renaming_by_replacing`

Modifier `renaming_by_replacing` (code)
See also
Num. of arguments	2–4
Repeatable	Yes
`mapping_by_mixing`, `mapping_to_lowercase`, `mapping_to_uppercase`, `mapping_by_calling`, `mapping_by_invoking`, `mapping_by_magic`, `mapping_by_replacing`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_invoking`, `renaming_by_magic`, `renaming_by_mixing`, `grouping_by_calling`, `#mixing_names_and_values`

Brief: Rename all parameters, replacing their former names with the text returned by a string substitutions
Syntax: {{#invoke:params|renaming_by_replacing|target|replace|[count]|[plain flag]|pipe function name}}

This modifier works similarly to mapping_by_replacing, but instead of replacing parameters' values it renames the parameters themselves. Care must be used knowing that if a new name collides with another new name one of the two parameters will be removed without knowing which one. New names and old names do not create collisions. If a name is returned identical it will be considered as "unchanged" and in case of conflicts the renamed one will prevail. Possible leading and trailing spaces in the new names are always stripped (however they are not stripped while searching for the name to replace).

Since there can be only one parameter name that matches exactly a literal string, when used with the strict flag this modifier directly accesses the requested key without looping through the entire list of parameters (so it will be much faster).

For instance, the following example renames all parameters of type |arg1=, |arg2=, … |argN= into |1=, |2= … |N=, thus creating a novel sequence:

{{#invoke:params|sequential|setting|h/i/p/f|[|][|: |]|with_name_matching|^arg%d+$|renaming_by_replacing|^arg(%d+)$|%1|1|list}}

This modifier can be particularly useful for sanitizing parameter names (e.g. collapsing several spaces into single spaces, changing the letter case, and so on).

For performance reasons this modifier uses string.gsub(); if you need to use mw.ustring.gsub() instead, you will need to invoke the replace function from Module:String via ...|renaming_by_invoking|string|replace|....

The following table shows examples of equivalent instructions. Please be aware that invoking mw.ustring.gsub() can be much slower.

`string.gsub()`	`mw.ustring.gsub()` (via Module:String)
`...\|renaming_by_replacing\|target\|replace\|...`	`...\|renaming_by_invoking\|string\|replace\|4\|target\|replace\|\|false\|...`
`...\|renaming_by_replacing\|target\|replace\|count\|...`	`...\|renaming_by_invoking\|string\|replace\|4\|target\|replace\|count\|false\|...`
`...\|renaming_by_replacing\|target\|replace\|plain\|...`	`...\|renaming_by_invoking\|string\|replace\|2\|target\|replace\|...` or, equivalently, `...\|renaming_by_invoking\|string\|replace\|4\|target\|replace\|\|true\|...`
`...\|renaming_by_replacing\|target\|replace\|count\|plain\|...`	`...\|renaming_by_invoking\|string\|replace\|3\|target\|replace\|count\|...` or, equivalently, `...\|renaming_by_invoking\|string\|replace\|4\|target\|replace\|count\|true\|...`

There is not a corresponding translation for the strict flag in Module:String. However, as it goes with the plain flag, in that case you won't need mw.ustring.gsub() in the first place.

Note: The target and replace arguments passed to this modifier will not be trimmed of their leading and trailing spaces. The or, plain, strict and pattern keywords, the count argument, and the mapping_by_replacing modifier name itself, instead, will be trimmed of their surrounding spaces.

`renaming_by_mixing`

Modifier `renaming_by_mixing` (code)
See also
Num. of arguments	1
Repeatable	Yes
`mapping_by_mixing`, `mapping_to_lowercase`, `mapping_to_uppercase`, `mapping_by_calling`, `mapping_by_invoking`, `mapping_by_magic`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_invoking`, `renaming_by_magic`, `renaming_by_replacing`, `grouping_by_calling`, `mixing_names_and_values`

Brief: Rename all parameters, replacing their former names with the expansion of a custom string containing the $# and $@ placeholders
Syntax: {{#invoke:params|renaming_by_mixing|mixing string|pipe function name}}

This modifier (temporarily) changes the content of the parameters the current template is being called with, replacing each of them with the expansion of a custom string that expects the same syntax as the for_each function.

For instance, the following code will wrap all parameter names in quotes

...|renaming_by_mixing|"$#"|...

whereas the following code will replace all parameter names with the string [NAME::VALUE], where NAME and VALUE are each parameter's name and value:

...|renaming_by_mixing|[$#::$@]|...

Note: The mixing string argument passed to this modifier will not be trimmed of its leading and trailing spaces. The renaming_by_mixing modifier name itself, instead, will be trimmed of its surrounding spaces.

`grouping_by_calling`

Modifier `grouping_by_calling` (code)
See also
Num. of arguments	Ad libitum
Repeatable	Yes^[2]
`mapping_to_lowercase`, `mapping_to_uppercase`, `call_for_each_group`, `mapping_by_calling`, `mapping_by_invoking`, `mapping_by_magic`, `mapping_by_replacing`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_invoking`, `renaming_by_magic`, `renaming_by_replacing`

Brief: Group the parameters that have the same numeric suffix into novel parameters, whose names will be numbers and whose values will be decided by a custom template
Syntax: {{#invoke:params|grouping_by_calling|template name|[let]|[...]|[number of additional arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe function name}}

This is the piping version of call_for_each_group. This means that after calling this modifier the old parameters will be (temporarily) gone and the only parameters left will be novel parameters whose names will be numbers (or an empty string if parameters without a numeric suffix were present) and whose content will be decided by a custom template.

Like other modifiers in the mapping_* and renaming_* family, it is possible to impose own parameters on the callback template by using the syntax ...|[let]|[...]|[number of additional arguments]|[argument 1]|[argument 2]|[...]|[argument N]|.... Unlike the other mapping_* and renaming_* modifiers, however (but like call_for_each_group), sequential parameters here will not be prepended, but will replace possible parsed parameters.

And so, writing

{{#invoke:params|...|grouping_by_calling|MY TEMPLATE|let|foo|bar|let|hello|world|3|one|two|three|list_values}}

is identical to writing

{{#invoke:params|...|call_for_each_group|MY TEMPLATE|foo=bar|hello=world|one|two|three}}

In the example above the main difference will be that the first solution will allow to pass the newly grouped parameters at once to another template or module (via concat_and_call or concat_and_invoke) or, if needed, perform further fine-tuning operations concerning the new parameters.

Please refer to the documentation of call_for_each_group for further information on the parameters passed to the callback template.

Note: All arguments passed to this modifier except the grouping_by_calling modifier name itself, the template name, the let keyword, the passed parameter names, and the number of additional parameters will not be trimmed of their leading and trailing spaces.

`parsing`

Modifier `parsing` (code)
See also
Num. of arguments	1–6
Repeatable	Yes
Often accompanied by	`new`
`new`, `{{#invoke:ArrayList}}`, `{{Array}}`

Brief: Create new parameters by parsing a parameter string
Syntax: {{#invoke:params|parsing|string to parse|[trim flag]|[iteration delimiter setter]|[...]|[key-value delimiter setter]|[...]|pipe function name}}

This modifier allows to add an infinity of new parameters by using a parameter string. By default this expects | as separator between parameters and = as separator between keys and values, but it is possible to specify other strings or patterns. The parsed parameters will overwrite existing parameters of the same name. For this reason, the new directive often accompanies this modifier.

Examples:

{{#invoke:params|new|parsing|one{{!}}two{{!}}three{{!}}foo{{=}}bar{{!}}hello{{=}}world|for_each|[$#:$@]}}
↳ [1:one][2:two][3:three][hello:world][foo:bar]
{{#invoke:params|new|parsing|one, two; three. foo: bar, hello: world|trim_all|splitter_pattern|[,;.]|setter_string|:|for_each|[$#:$@]}}
↳ [1:one][2:two][3:three][hello:world][foo:bar]
{{#invoke:params|new|parsing|one/two/ three / foo % bar /hello%world|setter_string|%|trim_none|splitter_string|/|for_each|[$#:$@]}}
↳ [1:one][2:two][3: three ][hello:world][foo: bar ]

The trim flag argument can be placed in any position after the string to parse (not necessarily in second position) and can have one of the following values: trim_none, trim_named, trim_positional, trim_all. If omitted, it defaults to trim_named.

The iteration delimiter setter can be placed in any position after the string to parse (not necessarily in third position), must be immediately followed by a user-given string, and can be either splitter_string or splitter_pattern. If omitted, the two arguments default to splitter_string|{{!}}. If the custom string is empty (but not if it is blank but not empty) the string to parse will be assumed not to have any iteration delimiters (this will result in one single parameter being parsed).

The key-value delimiter setter can be placed in any position after the string to parse (not necessarily in fifth position), must be immediately followed by a user-given string, and can be either setter_string or setter_pattern. If omitted, the two arguments default to setter_string|{{=}}. If the custom string is empty (but not if it is blank but not empty) the string to parse will be assumed not to have any key-value delimiters (this will result in a sequence-only list of parameters being parsed).

Possible options
Setting a trim flag	Setting an iteration delimiter	Setting a key-value delimiter
`trim_none` `trim_named` `trim_positional` `trim_all`	`splitter_string\|...` `splitter_pattern\|...`	`setter_string\|...` `setter_pattern\|...`

Note: All arguments passed to this modifier except the parsing modifier name itself, the trim flag, iteration delimiter setter and key-value delimiter setter arguments will not be trimmed of their leading and trailing spaces.

`reinterpreting`

Modifier `reinterpreting` (code)
See also
Num. of arguments	1–6
Repeatable	Yes
`parsing`, `{{#invoke:ArrayList}}`, `{{Array}}`

Brief: Use the content of a parameter as a parameter string to parse, after removing the parameter itself
Syntax: {{#invoke:params|reinterpreting|parameter name|[trim flag]|[iteration delimiter setter]|[...]|[key-value delimiter setter]|[...]|pipe function name}}

This modifier works exactly like parsing, but takes the content of a disposable parameter as input. See there for further information. The parameter passed to this modifier will be immediately deleted. The parsed parameters will overwrite existing parameters of the same name.

Example:

{{#invoke:params|new|pulling|1|reinterpreting|1|splitter_string|,|trim_all|concat_and_call|See also}}

An example that shows how to use this function to transclude a custom template with custom parameters is available at {{./doc/examples/constructed transclusion}}.

Note: All arguments passed to this modifier except the reinterpreting modifier name itself, the parameter name, trim flag, iteration delimiter setter and key-value delimiter setter arguments will not be trimmed of their leading and trailing spaces.

`evaluating`

Modifier `evaluating` (code)
See also
Num. of arguments	1–6
Repeatable	Yes
`parsing`, `reinterpreting`

Brief: Create new directives by parsing a parameter string
Syntax: {{#invoke:params|evaluating|string to parse|[trim flag]|[iteration delimiter setter]|[...]|[key-value delimiter setter]|[...]|pipe function name}}

In order to facilitate scripting, the directives wherewith this module is invoked can be added or removed on the fly. The evaluating modifier works exactly like parsing, but the parsed input will be interpreted as directives for this module rather than new template parameters (see there for further information).

All directives can be parsed through this modifier. Named parsed parameters will overwrite existing parameters of the same name. Unlike parsing, here the default separators are ! and : instead of {{!}} and {{=}}. Moreover a blank input will be discarded.

Example:

{{#invoke:params|new|
	all_sorted|
	setting|i/p|; | → |
	evaluating|{{#if:{{{SOMETHING|}}}
		| imposing!1!one!imposing!2!two!imposing!3!three
		| imposing!100!hundred!imposing!200!two hundred!imposing!300!three hundred
	}}
	|list
}}

Result:

100 → hundred; 200 → two hundred; 300 → three hundred

Note: All arguments passed to this modifier except the evaluating modifier name itself, the trim flag, iteration delimiter setter and key-value delimiter setter arguments will not be trimmed of their leading and trailing spaces.

`mixing_names_and_values`

Modifier `mixing_names_and_values` (code)
See also
Num. of arguments	2
Repeatable	Yes
`mapping_by_mixing`, `mapping_to_lowercase`, `mapping_to_uppercase`, `mapping_by_calling`, `mapping_by_invoking`, `mapping_by_magic`, `renaming_to_lowercase`, `renaming_to_uppercase`, `renaming_to_sequence`, `renaming_by_calling`, `renaming_by_invoking`, `renaming_by_magic`, `renaming_by_replacing`, `renaming_by_mixing`, `grouping_by_calling`

Brief: Rewrite all parameters, replacing names and values with the expansion of two custom strings containing the $# and $@ placeholders
Syntax: {{#invoke:params|mixing_names_and_values|name mixing string|value mixing string|pipe function name}}

This modifier (temporarily) changes names and values of the parameters the current template is being called with, replacing each of them with the expansion of two custom strings that expect the same syntax as the for_each function.

For instance, the following code will wrap all parameter names and values in quotes

...|mixing_names_and_values|"$#"|"$@"|...

whereas the following code will replace all names with the string VALUE/NAME and all values with the string [NAME::VALUE], where NAME and VALUE are each parameter's name and value:

...|mixing_names_and_values|$@/$#|[$#::$@]|...

Note: The value mixing string argument passed to this modifier will not be trimmed of its leading and trailing spaces. The name mixing string argument and mixing_names_and_values modifier name itself, instead, will be trimmed of their surrounding spaces.

`combining`

Num. of arguments 2–10 (variable)

Repeatable Yes

Memory slots

`p`	Key-value delimiter
`i`	Iteration delimiter
`l`	Last iteration delimiter
`h`	Header text
`f`	Footer text
`n`	Fallback text
`s`	"Serial-comma-like" last iteration delimiter

`combining_values`

Num. of arguments 2–10 (variable)

Repeatable Yes

Memory slots

`p`	Key-value delimiter (ignored)
`i`	Iteration delimiter
`l`	Last iteration delimiter
`h`	Header text
`f`	Footer text
`n`	Fallback text
`s`	"Serial-comma-like" last iteration delimiter

`combining_by_calling`

Modifier `combining_by_calling` (code)
See also
Num. of arguments	2
Repeatable	Yes
`combining`, `combining_values`, `combining_by_invoking`, `combining_by_magic`, `entering_substack`, `snapshotting`, `remembering`, `concat_and_call`

Brief: Pass all current parameters to a custom template and save the returned output as a new parameter
Syntax: {{#invoke:params|combining_by_calling|template name|new parameter name|pipe function name}}

This is the piping version of concat_and_call. This means that after calling this modifier the old parameters will be (temporarily) gone and the only parameter left will be what is specified in the new parameter name argument.

Since after using this modifier all parameters will be grouped into one single parameter, to pass additional parameters to the callback template you can safely use imposing, providing, splicing, or parsing.

For instance, using ./testcases/tdummy echo sb as callback template, a template named {{example template}} with the following content,

{{#invoke:params|combining_by_calling|module:params/testcases/tdummy echo sb|my_new_parameter|for_each|[$#:$@]}}

when transcluded as {{example template|one|two|three|hello=world|foo=bar}} will produce

[my_new_parameter:[1=one][2=two][3=three][hello=world][foo=bar]]

Note: All arguments passed to this modifier and the combining_by_calling modifier name will be trimmed of their leading and trailing spaces.

`combining_by_invoking`

Modifier `combining_by_invoking` (code)
See also
Num. of arguments	3
Repeatable	Yes
`combining`, `combining_values`, `combining_by_calling`, `combining_by_magic`, `entering_substack`, `snapshotting`, `remembering`, `concat_and_call`

Brief: Pass all current parameters to a custom module function and save the returned output as a new parameter
Syntax: {{#invoke:params|combining_by_invoking|module name|function name|new parameter name|pipe function name}}

This is the piping version of concat_and_invoke. It works similarly to how combining_by_calling works, except that it invokes a module function instead of calling a template. After calling this modifier the old parameters will be (temporarily) gone and the only parameter left will be what is specified in the new parameter name argument.

Since after using this modifier all parameters will be grouped into one single parameter, to pass additional parameters to the callback template you can safely use imposing, providing, splicing, or parsing.

Note: All arguments passed to this modifier and the combining_by_invoking modifier name will be trimmed of their leading and trailing spaces.

`combining_by_magic`

Modifier `combining_by_magic` (code)
See also
Num. of arguments	2
Repeatable	Yes
`combining`, `combining_values`, `combining_by_calling`, `combining_by_invoking`, `entering_substack`, `entering_substack`, `snapshotting`, `remembering`, `concat_and_call`

Brief: Pass all current parameters to a parser function and save the returned output as a new parameter
Syntax: {{#invoke:params|combining_by_magic|parser function|new parameter name|pipe function name}}

This is the piping version of concat_and_magic. It works similarly to how combining_by_calling works, except that it calls a parser function instead of calling a template. After calling this modifier the old parameters will be (temporarily) gone and the only parameter left will be what is specified in the new parameter name argument.

Since after using this modifier all parameters will be grouped into one single parameter, to pass additional parameters to the callback template you can safely use imposing, providing, splicing, or parsing.

Note: All arguments passed to this modifier and the combining_by_magic modifier name will be trimmed of their leading and trailing spaces.

`snapshotting`

Modifier `snapshotting` (code)
See also
Num. of arguments	0
Repeatable	Yes
Eventually followed by	Either `entering_substack` or `flushing`
`remembering`, `entering_substack`, `pulling`, `merging_substack`, `detaching_substack`, `dropping_substack`, `leaving_substack`, `flushing`

Brief: Push a copy of the current parameter list to the queue of parameter lists
Syntax: {{#invoke:params|snapshotting|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This module has a stacking mechanism that allows to isolate groups of parameters, work separately on them, and then merge them back to the original stack. The modifiers dedicated to this mechanism are:

snapshotting
remembering
entering_substack
pulling
detaching_substack
dropping_substack
leaving_substack
merging_substack
flushing

Every time the snapshotting modifier is used, the current list of parameters (together with their values) will be copied and added to a queue. When the entering_substack modifier is used, the list of parameters on top of the queue will temporarily become the current parameters, and all other modifiers will affect only this substack. After completing the job, the merging_substack will merge the current substack to the parent stack.

If no parameter lists have been snapshotted before calling entering_substack, the latter will automatically make a snapshot of the current parameters. Once inside a substack, it is possible to enter a subsubstack using the same machinery.

The detaching_substack modifier erases the current parameters from the parent stack, allowing the current stack to rename its parameters freely and merge them back to the parent stack, renamed.

It is possible to leave a substack without merging it to the parent by using the leaving_substack modifier. In this case, at some point it will be necessary to call flushing in order to merge the stack previously left unmerged. Alternatively, it will be possible to enter it again by calling entering_substack, and finally merge it via merging_substack. It is also possible to drop and discard a substack completely via dropping_substack

An example will probably clarify the mechanism better than anything else:

{{#invoke:params|new|<!-- Ignore the incoming parameters and manually assign some parameters (we will simulate the following incoming parameters: |one|two|three|four|foo=bar|hello=world ...) -->
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|4|four|
	imposing|foo|bar|
	imposing|hello|world|
	entering_substack|<!-- Enter into a substack (the `snapshotting` modifier will be automatically invoked for us) -->
		excluding_numeric_names|<!-- Exclude numeric parameters -->
		detaching_substack|<!-- Remove the current parameters from the parent stack -->
		renaming_by_replacing|^.*$|This was called "%0"|1|<!-- Rename the parameters in this substack -->
	merging_substack|
	entering_substack|new|<!-- Enter into a new empty substack -->
		pulling|1|<!-- Pull the parameter named "1" from the parent stack -->
		mapping_by_replacing|^.*$|This value once was "%0"|1|<!-- Replace the content of the parameters in this substack -->
	merging_substack|
for_each|[$#:$@]}}

The code above will result in:

[1:This value once was "one"][2:two][3:three][4:four][This was called "foo":bar][This was called "hello":world]

A more advanced example is available at {{./doc/examples/universal page list}}.

`remembering`

Modifier `remembering` (code)
See also
Num. of arguments	0
Repeatable	Yes
Eventually followed by	Either `entering_substack` or `flushing`
`snapshotting`, `entering_substack`, `pulling`, `merging_substack`, `detaching_substack`, `dropping_substack`, `leaving_substack`, `flushing`

Brief: Push a copy of the original (unmodified) parameter list to the queue of snapshots
Syntax: {{#invoke:params|remembering|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This modifier is somewhat similar to snapshotting, except that it retrieves the parameters that were originally passed to the calling template before being affected by the module's modifiers. The modifier works also after the new directive. See snapshotting for more information on the stacking mechanism.

`entering_substack`

Modifier `entering_substack` (code)
See also
Num. of arguments	0
Repeatable	Yes
May be immediately followed by	`new`
Eventually followed by	Either `merging_substack` or `leaving_substack` followed by `flushing`
`snapshotting`, `remembering`, `pulling`, `merging_substack`, `detaching_substack`, `dropping_substack`, `leaving_substack`, `flushing`

Brief: Enter the first stack in the queue of parameter lists, or copy the current parameters into a substack if the queue is empty
Syntax: {{#invoke:params|entering_substack|[new]|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

See snapshotting for more information on the stacking mechanism. Once in a substack, it is possible to go back to the parent stack using three different modifiers: merging_substack, leaving_substack and dropping_substack.

`pulling`

Modifier `pulling` (code)
See also
Num. of arguments	1
Repeatable	Yes
Often preceeded by	`new`
`snapshotting`, `remembering`, `merging_substack`, `detaching_substack`, `dropping_substack`, `leaving_substack`, `flushing`

Brief: Pull a single parameter from the parent stack or from the stack of the original parameters
Syntax: {{#invoke:params|pulling|parameter name|pipe function name}}

See snapshotting for more information on the stacking mechanism. If this modifer is not used in a substack, the parameter will be pulled from the original (unmodified) parameter list.

`detaching_substack`

Modifier `detaching_substack` (code)
See also
Num. of arguments	0
Repeatable	Yes
Restrictions	Usable only inside substacks
`snapshotting`, `remembering`, `entering_substack`, `pulling`, `dropping_substack`, `merging_substack`, `leaving_substack`, `flushing`

Brief: Remove from the parent stack the parameters that are present in the current stack
Syntax: {{#invoke:params|detaching_substack|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This modifer can only be used in a substack. See snapshotting for more information on the stacking mechanism.

`dropping_substack`

Modifier `dropping_substack` (code)
See also
Num. of arguments	0
Repeatable	Yes
Restrictions	Usable only inside substacks
`snapshotting`, `remembering`, `entering_substack`, `pulling`, `merging_substack`, `leaving_substack`, `flushing`

Brief: Go back to the parent stack dropping the current substack
Syntax: {{#invoke:params|dropping_substack|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This modifer can only be used in a substack. See snapshotting for more information on the stacking mechanism.

`leaving_substack`

Modifier `leaving_substack` (code)
See also
Num. of arguments	0
Repeatable	Yes
Restrictions	Usable only inside substacks
`snapshotting`, `remembering`, `entering_substack`, `pulling`, `merging_substack`, `detaching_substack`, `dropping_substack`, `flushing`

Brief: Leave the current substack without merging it, and return to the parent stack
Syntax: {{#invoke:params|leaving_substack|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This modifer can only be used in a substack. See snapshotting for more information on the stacking mechanism.

See flushing for an example of how to use this modifier.

`merging_substack`

Modifier `merging_substack` (code)
See also
Num. of arguments	0
Repeatable	Yes
Restrictions	Usable only inside substacks
`snapshotting`, `remembering`, `entering_substack`, `pulling`, `detaching_substack`, `dropping_substack`, `leaving_substack`, `flushing`

Brief: Leave the current stack after merging it with the parent stack, then return to the latter
Syntax: {{#invoke:params|merging_substack|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This modifer can only be used in a substack. See snapshotting for more information on the stacking mechanism.

`flushing`

Modifier `flushing` (code)
See also
Num. of arguments	0
Repeatable	Yes
`snapshotting`, `remembering`, `entering_substack`, `pulling`, `merging_substack`, `detaching_substack`, `dropping_substack`, `leaving_substack`

Brief: Merge the first stack in the queue of snapshotted parameters with the current stack.
Syntax: {{#invoke:params|flushing|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This modifier is used in conjunction with either leaving_substack or snapshotting. See snapshotting for more information on the stacking mechanism.

In the following wrapper of an {{example template}}, the three parameters |1=, |2=, and |3= are used as aliases for |title=, |author=, and |language= respectively. The flushing modifier ensures that in case both are present, the named alias will have the precedence over the positional alias.

{{#invoke:params|
	entering_substack|
		discarding|1|
		discarding|2|
		discarding|3|
	leaving_substack|
	renaming_by_replacing|1|title|strict|
	renaming_by_replacing|2|author|strict|
	renaming_by_replacing|3|language|strict|
	flushing|
	concat_and_call|example template
}}

`new`

Modifier `new` (code)
See also
Num. of arguments	0
Repeatable	No
Restrictions	First position only
`parsing`, `imposing`, `providing`, `splicing`, `discarding`

Brief: Get rid of all the incoming parameters and create a new (empty) parameter stack
Syntax: {{#invoke:params|new|pipe function name}}

This modifier does not take arguments besides the name of the function that will follow.

This modifier can only appear in first position, or if substacks are present, immediately after the entering_substack directive. When in first position, its main purpose is that of extending the facilities offered by this module (e.g. mapping_by_replacing, with_value_matching, etc.) to custom lists of strings, independently of the incoming parameters. When inside a stack, it signals that the snapshot of the current parameters must be ignored for that stack. The existence of the new modifier also facilitates debugging the module.

The newly created parameter stack can be populated via parsing, imposing, providing, or splicing. The incoming parameters can always be retrieved back using the remembering and pulling modifiers.

Examples:

{{#invoke:params|new|imposing|1|foo|imposing|2|bar|mapping_by_replacing|^.|!%1|list_values}}
↳ !foo!bar

Subpages

Module:Params/ChangeLog – Record of the most important changes in the module's code
Module:Params/testcases – Testing the module's capabilities
Module:Params/doc/examples – Some of the examples mentioned in this documentation

The complete list of subpages is available here.

Notes

^ To be precise, the order will not be strictly alphabetical, because this would imply that a template called with the following parameters {{foobar|-4=you|9=wanna|.=me?|11=marry|-8=do}} would see them reordered as follows: {{foobar|-8=do|-4=you|.=me?|9=wanna|11=marry}} (with the dot in the middle between negative and positive numbers). To avoid this, numbers are always displayed first (i.e. {{foobar|-8=do|-4=you|9=wanna|11=marry|.=me?}}).
^ Unless followed by renaming_by_replacing in few bizarre situations, there is virtually no use in calling this modifier more than once.

{{#invoke:TemplatePar}}
{{#invoke:ParameterCount}}
{{#invoke:Separated entries|main}}
{{#invoke:Enumerate|main}}
{{#invoke:Check for unknown parameters|check}}
{{#invoke:Check for deprecated parameters|check}}
{{#invoke:Check for clobbered parameters|check}}
{{#invoke:Parameter validation}}
{{#invoke:Expand wikitext|main}}
{{#invoke:For loop|main}} and {{For loop}}
{{#invoke:For nowiki|template}} and {{For nowiki}}
{{#invoke:Template wrapper|wrap}}
{{#invoke:ArrayList|function}}
{{#invoke:TEMPLATENAME|main}}
Project:TemplateData

The above documentation is transcluded from Module:Params/doc.
Editors can experiment in this module's sandbox and testcases pages.
Subpages of this module.

require[[strict]]


	---                                        ---
	---     LOCAL ENVIRONMENT                  ---
	---    ________________________________    ---
	---                                        ---



	--[[ Abstract utilities ]]--
	----------------------------


-- Helper function for `string.gsub()` (for managing zero-padded numbers)
local function zero_padded (str)
	return ('%03d%s'):format(#str, str)
end


-- Helper function for `table.sort()` (for natural sorting)
local function natural_sort (var1, var2)
	return var1:gsub('%d+', zero_padded) < var2:gsub('%d+', zero_padded)
end


-- Parse a parameter name string and return it as a string or a number
local function get_parameter_name (par_str)
	local ret = par_str:match'^%s*(.-)%s*$'
	if ret ~= '0' and ret:find'^%-?[1-9]%d*$' == nil then return ret end
	return tonumber(ret)
end


-- Return a copy or a reference to a table
local function copy_or_ref_table (src, refonly)
	if refonly then return src end
	local newtab = {}
	for key, val in pairs(src) do newtab[key] = val end
	return newtab
end


-- Remove some numeric elements from a table, shifting everything to the left
local function remove_numeric_keys (tbl, idx, len)
	local cache, tmp = {}, idx + len - 1
	for key, val in pairs(tbl) do
		if type(key) == 'number' and key >= idx then
			if key > tmp then cache[key - len] = val end
			tbl[key] = nil
		end
	end
	for key, val in pairs(cache) do tbl[key] = val end
end


-- Make a reduced copy of a table (shifting in both directions if necessary)
local function copy_table_reduced (tbl, idx, len)
	local ret, tmp = {}, idx + len - 1
	if idx > 0 then
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' or key < idx then
				ret[key] = val
			elseif key > tmp then ret[key - len] = val end
		end
	elseif tmp > 0 then
		local nshift = 1 - idx
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' then ret[key] = val
			elseif key > tmp then ret[key - tmp] = val
			elseif key < idx then ret[key + nshift] = val end
		end
	else
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' or key > tmp then
				ret[key] = val
			elseif key < idx then ret[key + len] = val end
		end
	end
	return ret
end


-- Make an expanded copy of a table (shifting in both directions if necessary)
local function copy_table_expanded (tbl, idx, len)
	local ret, tmp = {}, idx + len - 1
	if idx > 0 then
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' or key < idx then
				ret[key] = val
			else ret[key + len] = val end
		end
	elseif tmp > 0 then
		local nshift = idx - 1
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' then ret[key] = val
			elseif key > 0 then ret[key + tmp] = val
			elseif key < 1 then ret[key + nshift] = val end
		end
	else
		for key, val in pairs(tbl) do
			if type(key) ~= 'number' or key > tmp then
				ret[key] = val
			else ret[key - len] = val end
		end
	end
	return ret
end


-- Move a key from a table to another, but only if under a different name and
-- always parsing numeric strings as numbers
local function steal_if_renamed (val, src, skey, dest, dkey)
	local realkey = get_parameter_name(dkey)
	if skey ~= realkey then
		dest[realkey] = val
		src[skey] = nil
	end
end


-- Given a table, create two new tables containing the sorted list of keys
local function get_key_list_sorted (tbl, sort_fn)
	local nums, words, nn, nw = {}, {}, 0, 0
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			nn = nn + 1
			nums[nn] = key
		else
			nw = nw + 1
			words[nw] = key
		end
	end
	table.sort(nums)
	table.sort(words, sort_fn)
	return nums, words, nn, nw
end



	--[[ Public strings ]]--
	------------------------


-- Special match keywords (functions and modifiers MUST avoid these names)
local mkeywords = {
	['or'] = 0,
	pattern = 1,
	plain = 2,
	strict = 3
}


-- Sort functions (functions and modifiers MUST avoid these names)
local sortfunctions = {
	alphabetically = false,
	naturally = natural_sort
}


-- Callback styles for the `mapping_*` and `renaming_*` class of modifiers
-- (functions and modifiers MUST avoid these names)
--[[

Meanings of the columns:

  col[1] = Loop type (0-3)
  col[2] = Number of module arguments that the style requires (1-3)
  col[3] = Minimum number of sequential parameters passed to the callback
  col[4] = Name of the callback parameter where to place each parameter name
  col[5] = Name of the callback parameter where to place each parameter value
  col[6] = Argument in the modifier's invocation that will override `col[4]`
  col[7] = Argument in the modifier's invocation that will override `col[5]`

A value of `-1` indicates that no meaningful value is stored (i.e. `nil`)

]]--
local mapping_styles = {
	names_and_values = { 3, 2, 2, 1, 2, -1, -1 },
	values_and_names = { 3, 2, 2, 2, 1, -1, -1 },
	values_only = { 1, 2, 1, -1, 1, -1, -1 },
	names_only = { 2, 2, 1, 1, -1, -1, -1 },
	names_and_values_as = { 3, 4, 0, -1, -1, 2, 3 },
	names_only_as = { 2, 3, 0, -1, -1, 2, -1 },
	values_only_as = { 1, 3, 0, -1, -1, -1, 2 },
	blindly = { 0, 2, 0, -1, -1, -1, -1 }
}


-- Memory slots (functions and modifiers MUST avoid these names)
local memoryslots = {
	h = 'header',
	f = 'footer',
	i = 'itersep',
	l = 'lastsep',
	n = 'ifngiven',
	p = 'pairsep',
	s = 'oxfordsep'
}


-- Possible trimming modes for the `parsing` modifier
local trim_parse_opts = {
	trim_none = { false, false },
	trim_positional = { false, true },
	trim_named = { true, false },
	trim_all = { true, true }
}


-- Possible string modes for the iteration separator in the `parsing` and
-- `reinterpreting` modifiers
local isep_parse_opts = {
	splitter_pattern = false,
	splitter_string = true
}


-- Possible string modes for the key-value separator in the `parsing` and
-- `reinterpreting` modifiers
local psep_parse_opts = {
	setter_pattern = false,
	setter_string = true
}


-- Possible position references for the `splicing` modifier
local position_references = {
	add_nothing = 0,
	add_smallest_number = 1,
	add_last_of_sequence = 2,
	add_largest_number = 3
}


-- Functions and modifiers MUST avoid these names too: `let`



	--[[ Module's private environment ]]--
	--------------------------------------


-- Hard-coded name of the module (to avoid going through `frame:getTitle()`)
local modulename = 'Module:Params'


-- The functions listed here declare that they don't need the `frame.args`
-- metatable to be copied into a regular table; if they are modifiers they also
-- guarantee that they will make their own (modified) copy available
local refpipe = {
	call_for_each_group = true,
	coins = true,
	count = true,
	evaluating = true,
	for_each = true,
	list = true,
	list_values = true,
	list_maybe_with_names = true,
	value_of = true
}


-- The functions listed here declare that they don't need the
-- `frame:getParent().args` metatable to be copied into a regular table; if 
-- they are modifiers they also guarantee that they will make their own
-- (modified) copy available
local refparams = {
	call_for_each_group = true,
	combining = true,
	combining_by_calling = true,
	combining_values = true,
	concat_and_call = true,
	concat_and_invoke = true,
	concat_and_magic = true,
	count = true,
	grouping_by_calling = true,
	mixing_names_and_values = true,
	renaming_by_mixing = true,
	renaming_to_sequence = true,
	renaming_to_uppercase = true,
	renaming_to_lowercase = true,
	--renaming_to_values = true,
	shifting = true,
	splicing = true,
	--swapping_names_and_values = true,
	value_of = true,
	with_name_matching = true
}


-- Maximum number of numeric parameters that can be filled, if missing (we
-- chose an arbitrary number for this constant; you can discuss about its
-- optimal value at Module talk:Params)
local maxfill = 1024


-- The private table of functions
local library = {}


-- Functions and modifiers that can only be invoked in first position
local static_iface = {}


-- Create a new context
local function context_new (child_frame)
	local ctx = {}
	ctx.frame = child_frame:getParent()
	ctx.opipe = child_frame.args
	ctx.oparams = ctx.frame.args
	ctx.firstposonly = static_iface
	ctx.iterfunc = pairs
	ctx.sorttype = 0
	ctx.n_parents = 0
	ctx.n_children = 0
	ctx.n_available = maxfill
	return ctx
end


-- Move to the next action within the user-given list
local function context_iterate (ctx, n_forward)
	local nextfn
	if ctx.pipe[n_forward] ~= nil then
		nextfn = ctx.pipe[n_forward]:match'^%s*(.*%S)'
	end
	if nextfn == nil then error(modulename ..
		': You must specify a function to call', 0) end
	if library[nextfn] == nil then
		if ctx.firstposonly[nextfn] == nil then error(modulename ..
			': The function ‘' .. nextfn .. '’ does not exist', 0)
		else error(modulename .. ': The ‘' .. nextfn ..
			'’ directive can only appear in first position', 0)
		end
	end
	remove_numeric_keys(ctx.pipe, 1, n_forward)
	return library[nextfn]
end


-- Main loop
local function main_loop (ctx, start_with)
	local fn = start_with
	repeat fn = fn(ctx) until not fn
	if ctx.n_parents > 0 then error(modulename ..
		': One or more ‘merging_substack’ directives are missing', 0) end
	if ctx.n_children > 0 then error(modulename ..
		', For some of the snapshots either the ‘flushing’ directive is missing or a group has not been properly closed with ‘merging_substack’', 0) end
end


-- Load a `setting`-like directive string into the `dest` table
local function set_strings (dest, opts, start_from)
	local cmd
	if opts[start_from] == nil then return start_from - 1 end
	cmd = opts[start_from]:gsub('%s+', ''):gsub('/+', '/')
		:match'^/*(.*[^/])'
	if cmd == nil then return start_from end
	local amap, sep, argc = {}, string.byte('/'), start_from + 1
	local vname
	local chr
	for idx = 1, #cmd do
		chr = cmd:byte(idx)
		if chr == sep then
			for key, val in ipairs(amap) do
				dest[val] = opts[argc]
				amap[key] = nil
			end
			argc = argc + 1
		else
			vname = memoryslots[string.char(chr)]
			if vname == nil then error(modulename ..
				', ‘setting’: Unknown slot ‘' ..
				string.char(chr) .. '’', 0) end
			table.insert(amap, vname)
		end
	end
	for key, val in ipairs(amap) do dest[val] = opts[argc] end
	return argc
end


-- Add a new stack of parameters to `ctx.children`
local function push_cloned_stack (ctx, tbl)
	local newparams = {}
	local currsnap = ctx.n_children + 1
	if ctx.children == nil then ctx.children = { newparams }
	else ctx.children[currsnap] = newparams end
	for key, val in pairs(tbl) do newparams[key] = val end
	ctx.n_children = currsnap
end


-- Parse a raw argument containing a `sortfunctions` directive, or
-- `'without_sorting'`, or `nil`
local function load_sort_opt (raw_arg)
	if raw_arg == nil then return nil, 1, false end
	local tmp = raw_arg:match'^%s*(.-)%s*$'
	if tmp == 'without_sorting' then return nil, 2, false end
	tmp = sortfunctions[tmp]
	if tmp == nil then return nil, 1, false end
	return tmp or nil, 2, true
end


-- Parse optional user arguments of type `...|[let]|[...][number of additional
-- parameters]|[parameter 1]|[parameter 2]|[...]`
local function load_child_opts (src, start_from, append_after)
	local tbl, pin = {}, start_from
	local names
	if src[pin] ~= nil and src[pin]:match'^%s*let%s*$' and
		src[pin + 1] ~= nil and src[pin + 2] ~= nil
	then
		names = {}
		repeat
			names[get_parameter_name(src[pin + 1])] = src[pin + 2]
			pin = pin + 3
		until src[pin] == nil or not src[pin]:match'^%s*let%s*$' or
			src[pin + 1] == nil or src[pin + 2] == nil
	end
	local tmp = tonumber(src[pin])
	if tmp ~= nil and math.floor(tmp) == tmp then
		if tmp < 0 then tmp = -1 end
		local shf = append_after - pin
		for idx = pin + 1, pin + tmp do tbl[idx + shf] = src[idx] end
		pin = pin + tmp + 1
	end
	if names ~= nil then
		for key, val in pairs(names) do tbl[key] = val end
	end
	return tbl, pin
end


-- Load the optional arguments of some of the `mapping_*` and `renaming_*`
-- class of modifiers
local function load_callback_opts (src, n_skip, default_style)
	local style
	local shf
	local tmp = src[n_skip + 1]
	if tmp ~= nil then style = mapping_styles[tmp:match'^%s*(.-)%s*$'] end
	if style == nil then style, shf = default_style, n_skip - 1
	else shf = n_skip end
	local n_exist, karg, varg = style[3], style[4], style[5]
	tmp = style[6]
	if tmp > -1 then
		karg = src[tmp + shf]:match'^%s*(.-)%s*$'
		if karg == '0' or karg:find'^%-?[1-9]%d*$' ~= nil then
			karg = tonumber(karg)
			n_exist = math.max(n_exist, karg)
		end
	end
	tmp = style[7]
	if tmp > -1 then
		varg = src[tmp + shf]:match'^%s*(.-)%s*$'
		if varg == '0' or varg:find'^%-?[1-9]%d*$' ~= nil then
			varg = tonumber(varg)
			n_exist = math.max(n_exist, varg)
		end
	end
	local dest, nargs = load_child_opts(src, style[2] + shf, n_exist)
	tmp = style[1]
	if (tmp == 3 or tmp == 2) and dest[karg] ~= nil then
		tmp = tmp - 2 end
	if (tmp == 3 or tmp == 1) and dest[varg] ~= nil then
		tmp = tmp - 1 end
	return dest, nargs, tmp, karg, varg
end


-- Parse the arguments of some of the `mapping_*` and `renaming_*` class of
-- modifiers
local function load_replace_args (opts, whoami)
	if opts[1] == nil then error(modulename ..
		', ‘' .. whoami .. '’: No pattern string was given', 0) end
	if opts[2] == nil then error(modulename ..
		', ‘' .. whoami .. '’: No replacement string was given', 0) end
	local ptn, repl, nmax, argc = opts[1], opts[2], tonumber(opts[3]), 3
	if nmax ~= nil or (opts[3] or ''):match'^%s*$' ~= nil then argc = 4 end
	local flg = opts[argc]
	if flg ~= nil then flg = mkeywords[flg:match'^%s*(.-)%s*$'] end
	if flg == 0 then flg = nil elseif flg ~= nil then argc = argc + 1 end
	return ptn, repl, nmax, flg, argc, (nmax ~= nil and nmax < 1) or
		(flg == 3 and ptn == repl)
end


-- Parse the arguments of the `with_*_matching` class of modifiers
local function load_pattern_args (opts, whoami)
	local ptns, state, nptns, cnt = {}, 0, 0, 1
	local keyw
	for _, val in ipairs(opts) do
		if state == 0 then
			nptns, state = nptns + 1, -1
			ptns[nptns] = { val, false, false }
		else
			keyw = val:match'^%s*(.*%S)'
			if keyw == nil or mkeywords[keyw] == nil or (
				state > 0 and mkeywords[keyw] > 0
			) then break
			else
				state = mkeywords[keyw]
				if state > 1 then ptns[nptns][2] = true end
				if state == 3 then ptns[nptns][3] = true end
			end
		end
		cnt = cnt + 1
	end
	if state == 0 then error(modulename .. ', ‘' .. whoami ..
		'’: No pattern was given', 0) end
	return ptns, nptns, cnt
end


-- Load the optional arguments of the `parsing` and `reinterpreting` modifiers
local function load_parse_opts (opts, start_from, isp, psp)
	local tmp
	local optslots, noptslots, argc = { true, true, true }, 3, start_from
	local trimn, trimu, iplain, pplain = true, false, true, true
	repeat
		noptslots, tmp = noptslots - 1, opts[argc]
		if tmp == nil then break end
		tmp = tmp:match'^%s*(.-)%s*$'
		if optslots[1] ~= nil and trim_parse_opts[tmp] ~= nil then
			tmp = trim_parse_opts[tmp]
			trimn, trimu = tmp[1], tmp[2]
			optslots[1] = nil
		elseif optslots[2] ~= nil and isep_parse_opts[tmp] ~= nil then
			argc = argc + 1
			iplain, isp = isep_parse_opts[tmp], opts[argc]
			optslots[2] = nil
		elseif optslots[3] ~= nil and psep_parse_opts[tmp] ~= nil then
			argc = argc + 1
			pplain, psp = psep_parse_opts[tmp], opts[argc]
			optslots[3] = nil
		else break end
		argc = argc + 1
	until noptslots < 1
	return isp, iplain, psp, pplain, trimn, trimu, argc
end


-- Map parameters' values using a custom callback and a referenced table
local value_maps = {
	[0] = function (tbl, margs, karg, varg, fn)
		for key in pairs(tbl) do tbl[key] = fn() end
	end,
	[1] = function (tbl, margs, karg, varg, fn)
		for key, val in pairs(tbl) do
			margs[varg] = val
			tbl[key] = fn()
		end
	end,
	[2] = function (tbl, margs, karg, varg, fn)
		for key in pairs(tbl) do
			margs[karg] = key
			tbl[key] = fn()
		end
	end,
	[3] = function (tbl, margs, karg, varg, fn)
		for key, val in pairs(tbl) do
			margs[karg] = key
			margs[varg] = val
			tbl[key] = fn()
		end
	end
}


-- Private table for `map_names()`
local name_thieves = {
	[0] = function (cache, tbl, rargs, karg, varg, fn)
		for key, val in pairs(tbl) do
			steal_if_renamed(val, tbl, key, cache, fn())
		end
	end,
	[1] = function (cache, tbl, rargs, karg, varg, fn)
		for key, val in pairs(tbl) do
			rargs[varg] = val
			steal_if_renamed(val, tbl, key, cache, fn())
		end
	end,
	[2] = function (cache, tbl, rargs, karg, varg, fn)
		for key, val in pairs(tbl) do
			rargs[karg] = key
			steal_if_renamed(val, tbl, key, cache, fn())
		end
	end,
	[3] = function (cache, tbl, rargs, karg, varg, fn)
		for key, val in pairs(tbl) do
			rargs[karg] = key
			rargs[varg] = val
			steal_if_renamed(val, tbl, key, cache, fn())
		end
	end
}


-- Map parameters' names using a custom callback and a referenced table
local function map_names (tbl, rargs, karg, varg, looptype, fn)
	local cache = {}
	name_thieves[looptype](cache, tbl, rargs, karg, varg, fn)
	for key, val in pairs(cache) do tbl[key] = val end
end


-- Return a new table that contains `src` regrouped according to the numeric
-- suffixes in its keys
local function make_groups (src)
	-- NOTE: `src` might be the original metatable!
	local prefix
	local gid
	local groups = {}
	for key, val in pairs(src) do
		-- `key` must only be a string or a number...
		if type(key) == 'string' then
			prefix, gid = key:match'^%s*(.-)%s*(%-?%d*)%s*$'
			gid = tonumber(gid) or ''
		else
			prefix = ''
			gid = key
		end
		if groups[gid] == nil then groups[gid] = {} end
		if prefix == '0' or prefix:find'^%-?[1-9]%d*$' ~= nil then
			prefix = tonumber(prefix)
			if prefix < 1 then prefix = prefix - 1 end
		end
		groups[gid][prefix] = val
	end
	return groups
end


-- Split into parts a string containing the `$#` and `$@` placeholders and
-- return the information as a skeleton table, a canvas table and a length
local function parse_placeholder_string (target)
	local skel = {}
	local canvas = {}
	local idx = 1
	local s_pos = 1
	local e_pos = string.find(target, '%$[@#]', 1, false)
	while e_pos ~= nil do
		canvas[idx] = target:sub(s_pos, e_pos - 1)
		skel[idx + 1] = target:sub(e_pos, e_pos + 1) == '$@'
		idx = idx + 2
		s_pos = e_pos + 2
		e_pos = string.find(target, '%$[@#]', s_pos, false)
	end
	if (s_pos > target:len()) then idx = idx - 1
	else canvas[idx] = target:sub(s_pos) end
	return skel, canvas, idx
end


-- Populate a table by parsing a parameter string
local function parse_parameter_string (tbl, str, isp, ipl, psp, ppl, trn, tru)
	local key
	local val
	local spos1
	local spos2
	local pos1
	local pos2
	local pos3 = 0
	local idx = 1
	local lenplone = #str + 1
	if isp == nil or isp == '' then
		if psp == nil or psp == '' then
			if tru then tbl[idx] = str:match'^%s*(.-)%s*$'
			else tbl[idx] = str end
			return idx
		end
		spos1, spos2 = str:find(psp, 1, ppl)
		if spos1 == nil then
			key = idx
			if tru then val = str:match'^%s*(.-)%s*$'
			else val = str end
			idx = idx + 1
		else
			key = get_parameter_name(str:sub(1, spos1 - 1))
			val = str:sub(spos2 + 1)
			if trn then val = val:match'^%s*(.-)%s*$' end
		end
		tbl[key] = val
		return idx
	end
	if psp == nil or psp == '' then
		repeat
			pos1 = pos3 + 1
			pos2, pos3 = str:find(isp, pos1, ipl)
			val = str:sub(pos1, (pos2 or lenplone) - 1)
			if tru then val = val:match'^%s*(.-)%s*$' end
			tbl[idx] = val
			idx = idx + 1
		until pos2 == nil
		return idx
	end
	repeat
		pos1 = pos3 + 1
		pos2, pos3 = str:find(isp, pos1, ipl)
		val = str:sub(pos1, (pos2 or lenplone) - 1)
		spos1, spos2 = val:find(psp, 1, ppl)
		if spos1 == nil then
			key = idx
			if tru then val = val:match'^%s*(.-)%s*$' end
			idx = idx + 1
		else
			key = get_parameter_name(val:sub(1, spos1 - 1))
			val = val:sub(spos2 + 1)
			if trn then val = val:match'^%s*(.-)%s*$' end
		end
		tbl[key] = val
	until pos2 == nil
	return idx
end


-- Heavy lifting for `combining` and `combining_values`
local function combine_parameters (ctx, keyval_fn, whoami)
	-- NOTE: `ctx.params` might be the original metatable! This function
	-- MUST create a copy of it before returning
	local opts = ctx.pipe
	if ctx.pipe[1] == nil then error(modulename ..
		', ‘' .. whoami .. '’: No parameter name was provided', 0) end
	local tbl = ctx.params
	local vars = {}
	local sortfn, tmp, do_sort = load_sort_opt(opts[2])
	local argc = set_strings(vars, opts, tmp + 1)
	if argc < tmp then error(modulename ..
		', ‘' .. whoami .. '’: No setting directive was given', 0) end
	tmp = true
	for _ in pairs(tbl) do
		tmp = false
		break
	end
	if tmp then
		if vars.ifngiven ~= nil then
			ctx.params = {
				[get_parameter_name(ctx.pipe[1])] = vars.ifngiven
			}
		elseif tbl == ctx.oparams then ctx.params = {} end
		return argc
	end
	local cache
	local len
	if do_sort then
		local words
		cache, words, len, tmp = get_key_list_sorted(tbl, sortfn)
		for idx = 1, tmp do cache[len + idx] = words[idx] end
		len = len + tmp
	else
		cache = {}
		len = 0
		for key in pairs(tbl) do
			len = len + 1
			cache[len] = key
		end
	end
	local pmap, nss, kvs, pps = {}, 0, vars.pairsep or '', vars.itersep or ''
	for idx = 1, len do
		tmp = cache[idx]
		pmap[nss + 1] = pps
		pmap[nss + 2] = keyval_fn(tmp, tbl[tmp], kvs)
		nss = nss + 2
	end
	tmp = vars.oxfordsep or vars.lastsep
	if tmp ~= nil and nss > 4 then pmap[nss - 1] = tmp
	elseif nss > 2 and vars.lastsep ~= nil then
		pmap[nss - 1] = vars.lastsep
	end
	pmap[1] = vars.header or ''
	if vars.footer ~= nil then pmap[nss + 1] = vars.footer end
	ctx.params = { [get_parameter_name(ctx.pipe[1])] = table.concat(pmap) }
	return argc
end


-- Concatenate the numeric keys from the table of parameters to the numeric
-- keys from the table of options; non-numeric keys from the table of options
-- will prevail over colliding non-numeric keys from the table of parameters
local function concat_params (ctx)
	local retval, tbl, nmax = {}, ctx.params, table.maxn(ctx.pipe)
	if ctx.subset == 1 then
		-- We need only the sequence
		for key, val in ipairs(tbl) do retval[key + nmax] = val end
	else
		if ctx.subset == -1 then
			for key in ipairs(tbl) do tbl[key] = nil end
		end
		for key, val in pairs(tbl) do
			if type(key) == 'number' and key > 0 then
				retval[key + nmax] = val
			else retval[key] = val end
		end
	end
	for key, val in pairs(ctx.pipe) do retval[key] = val end
	return retval
end


-- Flush the parameters by calling a custom function for each value (after this
-- function has been invoked `ctx.params` will be no longer usable)
local function flush_params (ctx, fn)
	local tbl = ctx.params
	if ctx.subset == 1 then
		for key, val in ipairs(tbl) do fn(key, val) end
		return
	end
	if ctx.subset == -1 then
		for key, val in ipairs(tbl) do tbl[key] = nil end
	end
	if ctx.sorttype > 0 then
		local nums, words, nn, nw = get_key_list_sorted(tbl, natural_sort)
		if ctx.sorttype == 2 then
			for idx = 1, nw do fn(words[idx], tbl[words[idx]]) end
			for idx = 1, nn do fn(nums[idx], tbl[nums[idx]]) end
			return
		end
		for idx = 1, nn do fn(nums[idx], tbl[nums[idx]]) end
		for idx = 1, nw do fn(words[idx], tbl[words[idx]]) end
		return
	end
	if ctx.subset ~= -1 then
		for key, val in ipairs(tbl) do
			fn(key, val)
			tbl[key] = nil
		end
	end
	for key, val in pairs(tbl) do fn(key, val) end
end


-- Flush the parameters by calling one of two custom functions for each value
-- (after this function has been invoked `ctx.params` will be no longer usable)
local function mixed_flush_params (ctx, fn_seq, fn_oth)
	if ctx.subset == 1 then
		for key, val in ipairs(ctx.params) do fn_seq(key, val) end
		return
	end
	if ctx.subset == -1 then
		flush_params(ctx, fn_oth)
		return
	end
	local tbl = ctx.params
	if ctx.sorttype > 0 then
		local nums, words, nn, nw = get_key_list_sorted(tbl, natural_sort)
		local sequence = {}
		for key, val in ipairs(tbl) do sequence[key] = val end
		if ctx.sorttype == 2 then
			for idx = 1, nw do fn_oth(words[idx], tbl[words[idx]]) end
		end
		for idx = 1, nn do
			if sequence[nums[idx]] then
				fn_seq(nums[idx], sequence[nums[idx]])
			else
				fn_oth(nums[idx], tbl[nums[idx]])
			end
		end
		if ctx.sorttype ~= 2 then
			for idx = 1, nw do fn_oth(words[idx], tbl[words[idx]]) end
		end
		return
	end
	for key, val in ipairs(tbl) do
		fn_seq(key, val)
		tbl[key] = nil
	end
	for key, val in pairs(tbl) do fn_oth(key, val) end
end


-- Finalize and return a concatenated list
local function finalize_and_return_concatenated_list (ctx, lst, len, modsize)
	if len > 0 then
		local tmp = ctx.oxfordsep or ctx.lastsep
		if tmp ~= nil and len > modsize * 2 then
			lst[len - modsize + 1] = tmp
		elseif len > modsize and ctx.lastsep ~= nil then
			lst[len - modsize + 1] = ctx.lastsep
		end
		lst[1] = ctx.header or ''
		if ctx.footer ~= nil then lst[len + 1] = ctx.footer end
		ctx.text = table.concat(lst)
	else ctx.text = ctx.ifngiven or '' end
end



	--[[ Modifiers ]]--
	-----------------------------


-- Syntax:  #invoke:params|sequential|pipe to
library.sequential = function (ctx)
	if ctx.subset == -1 then error(modulename ..
		': The two directives ‘non-sequential’ and ‘sequential’ are in contradiction with each other', 0) end
	if ctx.sorttype > 0 then error(modulename ..
		': The ‘all_sorted’ and ‘reassorted’ directives are redundant when followed by ‘sequential’', 0) end
	ctx.iterfunc = ipairs
	ctx.subset = 1
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|non-sequential|pipe to
library['non-sequential'] = function (ctx)
	if ctx.subset == 1 then error(modulename ..
		': The two directives ‘sequential’ and ‘non-sequential’ are in contradiction with each other', 0) end
	ctx.iterfunc = pairs
	ctx.subset = -1
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|all_sorted|pipe to
library.all_sorted = function (ctx)
	if ctx.subset == 1 then error(modulename ..
		': The ‘all_sorted’ directive is redundant after ‘sequential’', 0) end
	if ctx.sorttype == 2 then error(modulename ..
		': The two directives ‘reassorted’ and ‘sequential’ are in contradiction with each other', 0) end
	ctx.sorttype = 1
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|reassorted|pipe to
library.reassorted = function (ctx)
	if ctx.subset == 1 then error(modulename ..
		': The ‘reassorted’ directive is redundant after ‘sequential’', 0) end
	if ctx.sorttype == 1 then error(modulename ..
		': The two directives ‘sequential’ and ‘reassorted’ are in contradiction with each other', 0) end
	ctx.sorttype = 2
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|setting|directives|...|pipe to
library.setting = function (ctx)
	local argc = set_strings(ctx, ctx.pipe, 1)
	if argc < 2 then error(modulename ..
		', ‘setting’: No directive was given', 0) end
	return context_iterate(ctx, argc + 1)
end


-- Syntax:  #invoke:params|scoring|new parameter name|pipe to
--[[
library.scoring = function (ctx)
	if ctx.pipe[1] == nil then error(modulename ..
		', ‘scoring’: No parameter name was provided', 0) end
	local retval = 0
	for _ in pairs(ctx.params) do retval = retval + 1 end
	ctx.params[ctx.pipe[1]:match'^%s*(.-)%s*$'] = tostring(retval)
	return context_iterate(ctx, 2)
end
]]--


-- Syntax:  #invoke:params|squeezing|pipe to
library.squeezing = function (ctx)
	local store, indices, tbl, newlen = {}, {}, ctx.params, 0
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			newlen = newlen + 1
			indices[newlen] = key
			store[key] = val
			tbl[key] = nil
		end
	end
	table.sort(indices)
	for idx = 1, newlen do tbl[idx] = store[indices[idx]] end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|filling_the_gaps|pipe to
library.filling_the_gaps = function (ctx)
	local tbl, tmp, nmin, nmax, nnums = ctx.params, {}, 1, nil, -1
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			if nmax == nil then
				if key < nmin then nmin = key end
				nmax = key
			elseif key > nmax then nmax = key
			elseif key < nmin then nmin = key end
			nnums = nnums + 1
			tmp[key] = val
		end
	end
	if nmax ~= nil and nmax - nmin > nnums then
		ctx.n_available = ctx.n_available + nmin + nnums - nmax
		if ctx.n_available < 0 then error(modulename ..
			', ‘filling_the_gaps’: It is possible to fill at most ' ..
			tostring(maxfill) .. ' parameters', 0) end
		for idx = nmin, nmax, 1 do tbl[idx] = '' end
		for key, val in pairs(tmp) do tbl[key] = val end
	end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|clearing|pipe to
library.clearing = function (ctx)
	local tbl = ctx.params
	local numerics = {}
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			numerics[key] = val
			tbl[key] = nil
		end
	end
	for key, val in ipairs(numerics) do tbl[key] = val end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|cutting|left cut|right cut|pipe to
library.cutting = function (ctx)
	local lcut = tonumber(ctx.pipe[1])
	if lcut == nil or math.floor(lcut) ~= lcut then error(modulename ..
		', ‘cutting’: Left cut must be an integer number', 0) end
	local rcut = tonumber(ctx.pipe[2])
	if rcut == nil or math.floor(rcut) ~= rcut then error(modulename ..
		', ‘cutting’: Right cut must be an integer number', 0) end
	local tbl = ctx.params
	local len = #tbl
	if lcut < 0 then lcut = len + lcut end
	if rcut < 0 then rcut = len + rcut end
	local tot = lcut + rcut
	if tot > 0 then
		local cache = {}
		if tot >= len then
			for key in ipairs(tbl) do tbl[key] = nil end
			tot = len
		else
			for idx = len - rcut + 1, len, 1 do tbl[idx] = nil end
			for idx = 1, lcut, 1 do tbl[idx] = nil end
		end
		for key, val in pairs(tbl) do
			if type(key) == 'number' and key > 0 then
				if key > len then cache[key - tot] = val
				else cache[key - lcut] = val end
				tbl[key] = nil
			end
		end
		for key, val in pairs(cache) do tbl[key] = val end
	end
	return context_iterate(ctx, 3)
end


-- Syntax:  #invoke:params|cropping|left crop|right crop|pipe to
library.cropping = function (ctx)
	local lcut = tonumber(ctx.pipe[1])
	if lcut == nil or math.floor(lcut) ~= lcut then error(modulename ..
		', ‘cropping’: Left crop must be an integer number', 0) end
	local rcut = tonumber(ctx.pipe[2])
	if rcut == nil or math.floor(rcut) ~= rcut then error(modulename ..
		', ‘cropping’: Right crop must be an integer number', 0) end
	local tbl = ctx.params
	local nmin
	local nmax
	for key in pairs(tbl) do
		if type(key) == 'number' then
			if nmin == nil then nmin, nmax = key, key
			elseif key > nmax then nmax = key
			elseif key < nmin then nmin = key end
		end
	end
	if nmin ~= nil then
		local len = nmax - nmin + 1
		if lcut < 0 then lcut = len + lcut end
		if rcut < 0 then rcut = len + rcut end
		if lcut + rcut - len > -1 then
			for key in pairs(tbl) do
				if type(key) == 'number' then tbl[key] = nil end
			end
		elseif lcut + rcut > 0 then
			for idx = nmax - rcut + 1, nmax do tbl[idx] = nil end
			for idx = nmin, nmin + lcut - 1 do tbl[idx] = nil end
			local lshift = nmin + lcut - 1
			if lshift > 0 then
				for idx = lshift + 1, nmax, 1 do
					tbl[idx - lshift] = tbl[idx]
					tbl[idx] = nil
				end
			end
		end
	end
	return context_iterate(ctx, 3)
end


-- Syntax:  #invoke:params|purging|start offset|length|pipe to
library.purging = function (ctx)
	local idx = tonumber(ctx.pipe[1])
	if idx == nil or math.floor(idx) ~= idx then error(modulename ..
		', ‘purging’: Start offset must be an integer number', 0) end
	local len = tonumber(ctx.pipe[2])
	if len == nil or math.floor(len) ~= len then error(modulename ..
		', ‘purging’: Length must be an integer number', 0) end
	local tbl = ctx.params
	if len < 1 then
		len = len + table.maxn(tbl)
		if idx > len then return context_iterate(ctx, 3) end
		len = len - idx + 1
	end
	ctx.params = copy_table_reduced(tbl, idx, len)
	return context_iterate(ctx, 3)
end


-- Syntax:  #invoke:params|backpurging|start offset|length|pipe to
library.backpurging = function (ctx)
	local last = tonumber(ctx.pipe[1])
	if last == nil or math.floor(last) ~= last then error(modulename ..
		', ‘backpurging’: Start offset must be an integer number', 0) end
	local len = tonumber(ctx.pipe[2])
	if len == nil or math.floor(len) ~= len then error(modulename ..
		', ‘backpurging’: Length must be an integer number', 0) end
	local idx
	local tbl = ctx.params
	if len > 0 then
		idx = last - len + 1
	else
		for key in pairs(tbl) do
			if type(key) == 'number' and (idx == nil or
				key < idx) then idx = key end
		end
		if idx == nil then return context_iterate(ctx, 3) end
		idx = idx - len
		if last < idx then return context_iterate(ctx, 3) end
		len = last - idx + 1
	end
	ctx.params = copy_table_reduced(ctx.params, idx, len)
	return context_iterate(ctx, 3)
end


-- Syntax:  #invoke:params|shifting|addend|pipe to
library.shifting = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local nshift = tonumber(ctx.pipe[1])
	if nshift == nil or nshift == 0 or math.floor(nshift) ~= nshift then
		error(modulename .. ', ‘shifting’: A non-zero integer number must be provided', 0) end
	local tbl = {}
	for key, val in pairs(ctx.params) do
		if type(key) == 'number' then tbl[key + nshift] = val
		else tbl[key] = val end
	end
	ctx.params = tbl
	return context_iterate(ctx, 2)
end


-- Syntax:  #invoke:params|reversing_numeric_names|pipe to
library.reversing_numeric_names = function (ctx)
	local tbl, numerics, nmax = ctx.params, {}, 0
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			numerics[key] = val
			tbl[key] = nil
			if key > nmax then nmax = key end
		end
	end
	for key, val in pairs(numerics) do tbl[nmax - key + 1] = val end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|pivoting_numeric_names|pipe to
--[[
library.pivoting_numeric_names = function (ctx)
	local tbl = ctx.params
	local shift = #tbl + 1
	if shift < 2 then return library.reversing_numeric_names(ctx) end
	local numerics = {}
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			numerics[key] = val
			tbl[key] = nil
		end
	end
	for key, val in pairs(numerics) do tbl[shift - key] = val end
	return context_iterate(ctx, 1)
end
]]--


-- Syntax:  #invoke:params|mirroring_numeric_names|pipe to
--[[
library.mirroring_numeric_names = function (ctx)
	local tbl, numerics = ctx.params, {}
	local nmax
	local nmin
	for key, val in pairs(tbl) do
		if type(key) == 'number' then
			numerics[key] = val
			tbl[key] = nil
			if nmax == nil then nmin, nmax = key, key
			elseif key > nmax then nmax = key
			elseif key < nmin then nmin = key end
		end
	end
	for key, val in pairs(numerics) do tbl[nmax + nmin - key] = val end
	return context_iterate(ctx, 1)
end
]]--


-- Syntax:  #invoke:params|swapping_numeric_names|pipe to
--[[
library.swapping_numeric_names = function (ctx)
	local tbl, cache, nsize = ctx.params, {}, 0
	local tmp
	for key in pairs(tbl) do
		if type(key) == 'number' then
			nsize = nsize + 1
			cache[nsize] = key
		end
	end
	table.sort(cache)
	for idx = math.floor(nsize / 2), 1, -1 do
		tmp = tbl[cache[idx] ]
		tbl[cache[idx] ] = tbl[cache[nsize - idx + 1] ]
		tbl[cache[nsize - idx + 1] ] = tmp
	end
	return context_iterate(ctx, 1)
end
]]--


-- Syntax:  #invoke:params|sorting_sequential_values|[criterion]|pipe to
library.sorting_sequential_values = function (ctx)
	local sortfn
	if ctx.pipe[1] ~= nil then
		sortfn = sortfunctions[ctx.pipe[1]:match'^%s*(.-)%s*$']
	end
	if sortfn then table.sort(ctx.params, sortfn)
	else table.sort(ctx.params) end -- i.e. either `false` or `nil`
	if sortfn == nil then return context_iterate(ctx, 1) end
	return context_iterate(ctx, 2)
end


-- Syntax:  #invoke:params|splicing|[add to position]|position|increment|
--            [number of elements to write]|...|pipe to
library.splicing = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local opts, tbl = ctx.pipe, ctx.params
	local tmp1 = opts[1]
	local tmp2
	local argc
	local pos
	local refp
	if tmp1 ~= nil then
		tmp2 = tonumber(tmp1)
		if tmp2 == nil or math.floor(tmp2) ~= tmp2 then
			pos, argc, tmp2 = tonumber(opts[2]), 4,
				tmp1:match'^%s*(.*%S)'
			if tmp2 ~= nil then
				refp = position_references[tmp2]
				if refp == nil then error(modulename ..
					', ‘splicing’: ‘' .. tostring(tmp2) ..
					'’ is not a valid first argument', 0) end
			else refp = 0 end
		else pos, argc, refp = tmp2, 3, 0 end
	else pos, argc, refp = tonumber(opts[2]), 4, 0 end
	if pos == nil or math.floor(pos) ~= pos then error(modulename ..
		', ‘splicing’: The position must be an integer number', 0) end
	local len = tonumber(opts[argc - 1])
	if len == nil or math.floor(len) ~= len then error(modulename ..
		', ‘splicing’: The increment must be an integer number', 0) end
	if refp == 2 then
		for _ in ipairs(tbl) do pos = pos + 1 end
		refp = 0
	end
	tmp1, tmp2 = nil, nil
	if refp ~= 0 or len ~= 0 then
		for key, val in pairs(tbl) do
			if type(key) == 'number' then
				if tmp1 == nil then tmp1, tmp2 = key, key
				elseif key < tmp1 then tmp1 = key
				elseif key > tmp2 then tmp2 = key end
			end
		end
	end
	if tmp2 == nil then len = 0
	elseif refp == 3 then pos = pos + tmp2
	elseif refp == 1 then pos = pos + tmp1 end
	if len > 0 and pos + len > tmp1 and pos <= tmp2 then
		tbl = copy_table_expanded(tbl, pos, len)
	elseif len < 0 and pos - len > tmp1 and pos <= tmp2 then
		tbl = copy_table_reduced(tbl, pos, -len)
	else tbl = copy_or_ref_table(tbl, tbl ~= ctx.oparams) end
	ctx.params = tbl
	tmp1 = tonumber(opts[argc])
	if len == 0 and (tmp1 == nil or tmp1 < 1) then error(modulename ..
		', ‘splicing’: When the increment is zero the number of elements to add cannot be zero', 0) end
	if tmp1 == nil or tmp1 < 0 or math.floor(tmp1) ~= tmp1 then
		return context_iterate(ctx, argc)
	end
	tmp2 = argc - pos + 1
	for key = pos, pos + tmp1 - 1 do tbl[key] = opts[key + tmp2] end
	return context_iterate(ctx, argc + tmp1 + 1)
end


-- Syntax:  #invoke:params|imposing|name|value|pipe to
library.imposing = function (ctx)
	if ctx.pipe[1] == nil then error(modulename ..
		', ‘imposing’: Missing parameter name to impose', 0) end
	ctx.params[get_parameter_name(ctx.pipe[1])] = ctx.pipe[2]
	return context_iterate(ctx, 3)
end


-- Syntax:  #invoke:params|providing|name|value|pipe to
library.providing = function (ctx)
	if ctx.pipe[1] == nil then error(modulename ..
		', ‘providing’: Missing parameter name to provide', 0) end
	local key = get_parameter_name(ctx.pipe[1])
	if ctx.params[key] == nil then ctx.params[key] = ctx.pipe[2] end
	return context_iterate(ctx, 3)
end


-- Syntax:  #invoke:params|discarding|name|[how many]|pipe to
library.discarding = function (ctx)
	if ctx.pipe[1] == nil then error(modulename ..
		', ‘discarding’: Missing parameter name to discard', 0) end
	local len = tonumber(ctx.pipe[2])
	if len == nil then
		ctx.params[get_parameter_name(ctx.pipe[1])] = nil
		return context_iterate(ctx, 2)
	end
	local key = tonumber(ctx.pipe[1])
	if key == nil or math.floor(key) ~= key then error(modulename ..
		', ‘discarding’: A range was provided, but the initial parameter name is not an integer number', 0) end
	if len < 1 or math.floor(len) ~= len then error(modulename ..
		', ‘discarding’: A range can only be an integer number greater than zero', 0) end
	for idx = key, key + len - 1 do ctx.params[idx] = nil end
	return context_iterate(ctx, 3)
end


-- Syntax:  #invoke:params|excluding_non-numeric_names|pipe to
library['excluding_non-numeric_names'] = function (ctx)
	local tmp = ctx.params
	for key, val in pairs(tmp) do
		if type(key) ~= 'number' then tmp[key] = nil end
	end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|excluding_numeric_names|pipe to
library.excluding_numeric_names = function (ctx)
	local tmp = ctx.params
	for key, val in pairs(tmp) do
		if type(key) == 'number' then tmp[key] = nil end
	end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|with_name_matching|target 1|[plain flag 1]|[or]
--            |[target 2]|[plain flag 2]|[or]|[...]|[target N]|[plain flag
--            N]|pipe to
library.with_name_matching = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local targets, nptns, argc = load_pattern_args(ctx.pipe,
		'with_name_matching')
	local tmp
	local ptn
	local tbl = ctx.params
	local newparams = {}
	for idx = 1, nptns do
		ptn = targets[idx]
		if ptn[3] then
			tmp = ptn[1]
			if tmp == '0' or tmp:find'^%-?[1-9]%d*$' ~= nil then
				tmp = tonumber(tmp)
			end
			newparams[tmp] = tbl[tmp]
		else
			for key, val in pairs(tbl) do
				if tostring(key):find(ptn[1], 1, ptn[2]) then
					newparams[key] = val
				end
			end
		end
	end
	ctx.params = newparams
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|with_name_not_matching|target 1|[plain flag 1]
--            |[and]|[target 2]|[plain flag 2]|[and]|[...]|[target N]|[plain
--            flag N]|pipe to
library.with_name_not_matching = function (ctx)
	local targets, nptns, argc = load_pattern_args(ctx.pipe,
		'with_name_not_matching')
	local tbl = ctx.params
	if nptns == 1 and targets[1][3] then
		local tmp = targets[1][1]
		if tmp == '0' or tmp:find'^%-?[1-9]%d*$' ~= nil then
			tbl[tonumber(tmp)] = nil
		else tbl[tmp] = nil end
		return context_iterate(ctx, argc)
	end
	local yesmatch
	local ptn
	for key in pairs(tbl) do
		yesmatch = true
		for idx = 1, nptns do
			ptn = targets[idx]
			if ptn[3] then
				if tostring(key) ~= ptn[1] then
					yesmatch = false
					break
				end
			elseif not tostring(key):find(ptn[1], 1, ptn[2]) then
				yesmatch = false
				break
			end
		end
		if yesmatch then tbl[key] = nil end
	end
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|with_value_matching|target 1|[plain flag 1]|[or]
--            |[target 2]|[plain flag 2]|[or]|[...]|[target N]|[plain flag
--            N]|pipe to
library.with_value_matching = function (ctx)
	local tbl = ctx.params
	local targets, nptns, argc = load_pattern_args(ctx.pipe,
		'with_value_matching')
	local nomatch
	local ptn
	for key, val in pairs(tbl) do
		nomatch = true
		for idx = 1, nptns do
			ptn = targets[idx]
			if ptn[3] then
				if val == ptn[1] then
					nomatch = false
					break
				end
			elseif val:find(ptn[1], 1, ptn[2]) then
				nomatch = false
				break
			end
		end
		if nomatch then tbl[key] = nil end
	end
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|with_value_not_matching|target 1|[plain flag 1]
--            |[and]|[target 2]|[plain flag 2]|[and]|[...]|[target N]|[plain
--            flag N]|pipe to
library.with_value_not_matching = function (ctx)
	local tbl = ctx.params
	local targets, nptns, argc = load_pattern_args(ctx.pipe,
		'with_value_not_matching')
	local yesmatch
	local ptn
	for key, val in pairs(tbl) do
		yesmatch = true
		for idx = 1, nptns do
			ptn = targets[idx]
			if ptn[3] then
				if val ~= ptn[1] then
					yesmatch = false
					break
				end
			elseif not val:find(ptn[1], 1, ptn[2]) then
				yesmatch = false
				break
			end
		end
		if yesmatch then tbl[key] = nil end
	end
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|trimming_values|pipe to
library.trimming_values = function (ctx)
	local tbl = ctx.params
	for key, val in pairs(tbl) do tbl[key] = val:match'^%s*(.-)%s*$' end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|mapping_to_lowercase|pipe to
library.mapping_to_lowercase = function (ctx)
	local tbl = ctx.params
	for key, val in pairs(tbl) do tbl[key] = val:lower() end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|mapping_to_uppercase|pipe to
library.mapping_to_uppercase = function (ctx)
	local tbl = ctx.params
	for key, val in pairs(tbl) do tbl[key] = val:upper() end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|mapping_by_calling|template name|[call
--            style]|[let]|[...][number of additional parameters]|[parameter
--            1]|[parameter 2]|[...]|[parameter N]|pipe to
library.mapping_by_calling = function (ctx)
	local opts = ctx.pipe
	local tname
	if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end
	if tname == nil then error(modulename ..
		', ‘mapping_by_calling’: No template name was provided', 0) end
	local margs, argc, looptype, karg, varg = load_callback_opts(opts, 1,
		mapping_styles.values_only)
	local model = { title = tname, args = margs }
	value_maps[looptype](ctx.params, margs, karg, varg, function ()
		return ctx.frame:expandTemplate(model)
	end)
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|mapping_by_invoking|module name|function
--            name|[call style]|[let]|[...]|[number of additional
--            arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe to
library.mapping_by_invoking = function (ctx)
	local opts = ctx.pipe
	local mname
	local fname
	if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end
	if mname == nil then error(modulename ..
		', ‘mapping_by_invoking’: No module name was provided', 0) end
	if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end
	if fname == nil then error(modulename ..
		', ‘mapping_by_invoking’: No function name was provided', 0) end
	local margs, argc, looptype, karg, varg = load_callback_opts(opts, 2,
		mapping_styles.values_only)
	local model = { title = 'Module:' .. mname, args = margs }
	local mfunc = require(model.title)[fname]
	if mfunc == nil then error(modulename ..
		', ‘mapping_by_invoking’: The function ‘' .. fname ..
		'’ does not exist', 0) end
	value_maps[looptype](ctx.params, margs, karg, varg, function ()
		return tostring(mfunc(ctx.frame:newChild(model)))
	end)
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|mapping_by_magic|parser function|[call
--            style]|[let]|[...][number of additional arguments]|[argument
--            1]|[argument 2]|[...]|[argument N]|pipe to
library.mapping_by_magic = function (ctx)
	local opts = ctx.pipe
	local magic
	if opts[1] ~= nil then magic = opts[1]:match'^%s*(.*%S)' end
	if magic == nil then error(modulename ..
		', ‘mapping_by_magic’: No parser function was provided', 0) end
	local margs, argc, looptype, karg, varg = load_callback_opts(opts, 1,
		mapping_styles.values_only)
	value_maps[looptype](ctx.params, margs, karg, varg, function ()
		return ctx.frame:callParserFunction(magic, margs)
	end)
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|mapping_by_replacing|target|replace|[count]|[plain
--            flag]|pipe to
library.mapping_by_replacing = function (ctx)
	local ptn, repl, nmax, flg, argc, die =
		load_replace_args(ctx.pipe, 'mapping_by_replacing')
	if die then return context_iterate(ctx, argc) end
	local tbl = ctx.params
	if flg == 3 then
		for key, val in pairs(tbl) do
			if val == ptn then tbl[key] = repl end
		end
	else
		if flg == 2 then
			-- Copied from Module:String's `str._escapePattern()`
			ptn = ptn:gsub('[%(%)%.%%%+%-%*%?%[%^%$%]]', '%%%0')
		end
		for key, val in pairs(tbl) do
			tbl[key] = val:gsub(ptn, repl, nmax)
		end
	end
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|mapping_by_mixing|mixing string|pipe to
library.mapping_by_mixing = function (ctx)
	if ctx.pipe[1] == nil then error(modulename ..
		', ‘mapping_by_mixing’: No mixing string was provided', 0) end
	local mix = ctx.pipe[1]
	local tbl = ctx.params
	if mix == '$#' then
		for key in pairs(tbl) do tbl[key] = tostring(key) end
		return context_iterate(ctx, 2)
	end
	local skel, cnv, n_parts = parse_placeholder_string(mix)
	for key, val in pairs(tbl) do
		for idx = 2, n_parts, 2 do
			if skel[idx] then cnv[idx] = val else cnv[idx] = tostring(key) end
		end
		tbl[key] = table.concat(cnv)
	end
	return context_iterate(ctx, 2)
end


-- Syntax:  #invoke:params|mapping_to_names|pipe to
--[[
library.mapping_to_names = function (ctx)
	local tbl = ctx.params
	for key in pairs(tbl) do tbl[key] = tostring(key) end
	return context_iterate(ctx, 1)
end
]]--


-- Syntax:  #invoke:params|renaming_to_lowercase|pipe to
library.renaming_to_lowercase = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local cache = {}
	for key, val in pairs(ctx.params) do
		if type(key) == 'string' then cache[key:lower()] = val else
		cache[key] = val end
	end
	ctx.params = cache
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|renaming_to_uppercase|pipe to
library.renaming_to_uppercase = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local cache = {}
	for key, val in pairs(ctx.params) do
		if type(key) == 'string' then cache[key:upper()] = val else
		cache[key] = val end
	end
	ctx.params = cache
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|renaming_to_sequence|[sort order]|pipe to
library.renaming_to_sequence = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local tbl = ctx.params
	local sortfn, argc, do_sort = load_sort_opt(ctx.pipe[1])
	local cache
	local len
	if do_sort then
		local words
		local wl
		cache, words, len, wl = get_key_list_sorted(tbl, sortfn)
		for idx = 1, len do cache[idx] = tbl[cache[idx]] end
		for idx = 1, wl do cache[len + idx] = tbl[words[idx]] end
	else
		cache = {}
		len = 0
		for _, val in pairs(tbl) do
			len = len + 1
			cache[len] = val
		end
	end
	ctx.params = cache
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|renaming_by_calling|template name|[call
--            style]|[let]|[...][number of additional parameters]|[parameter
--            1]|[parameter 2]|[...]|[parameter N]|pipe to
library.renaming_by_calling = function (ctx)
	local opts = ctx.pipe
	local tname
	if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end
	if tname == nil then error(modulename ..
		', ‘renaming_by_calling’: No template name was provided', 0) end
	local rargs, argc, looptype, karg, varg = load_callback_opts(opts, 1,
		mapping_styles.names_only)
	local model = { title = tname, args = rargs }
	map_names(ctx.params, rargs, karg, varg, looptype, function ()
		return ctx.frame:expandTemplate(model)
	end)
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|renaming_by_invoking|module name|function
--            name|[call style]|[let]|[...]|[number of additional
--            arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe to
library.renaming_by_invoking = function (ctx)
	local opts = ctx.pipe
	local mname
	local fname
	if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end
	if mname == nil then error(modulename ..
		', ‘renaming_by_invoking’: No module name was provided', 0) end
	if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end
	if fname == nil then error(modulename ..
		', ‘renaming_by_invoking’: No function name was provided', 0) end
	local rargs, argc, looptype, karg, varg = load_callback_opts(opts, 2,
		mapping_styles.names_only)
	local model = { title = 'Module:' .. mname, args = rargs }
	local mfunc = require(model.title)[fname]
	if mfunc == nil then error(modulename ..
		', ‘renaming_by_invoking’: The function ‘' .. fname ..
		'’ does not exist', 0) end
	map_names(ctx.params, rargs, karg, varg, looptype, function ()
		return tostring(mfunc(ctx.frame:newChild(model)))
	end)
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|renaming_by_magic|parser function|[call
--            style]|[let]|[...][number of additional arguments]|[argument
--            1]|[argument 2]|[...]|[argument N]|pipe to
library.renaming_by_magic = function (ctx)
	local opts = ctx.pipe
	local magic
	if opts[1] ~= nil then magic = opts[1]:match'^%s*(.*%S)' end
	if magic == nil then error(modulename ..
		', ‘renaming_by_magic’: No parser function was provided', 0) end
	local rargs, argc, looptype, karg, varg = load_callback_opts(opts, 1,
		mapping_styles.names_only)
	map_names(ctx.params, rargs, karg, varg, looptype, function ()
		return ctx.frame:callParserFunction(magic, rargs)
	end)
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|renaming_by_replacing|target|replace|[count]|[plain
--            flag]|pipe to
library.renaming_by_replacing = function (ctx)
	local ptn, repl, nmax, flg, argc, die =
		load_replace_args(ctx.pipe, 'renaming_by_replacing')
	if die then return context_iterate(ctx, argc) end
	local tbl = ctx.params
	if flg == 3 then
		ptn = get_parameter_name(ptn)
		local val = tbl[ptn]
		if val ~= nil then
			tbl[ptn] = nil
			tbl[get_parameter_name(repl)] = val
		end
	else
		if flg == 2 then
			-- Copied from Module:String's `str._escapePattern()`
			ptn = ptn:gsub('[%(%)%.%%%+%-%*%?%[%^%$%]]', '%%%0')
		end
		local cache = {}
		for key, val in pairs(tbl) do
			steal_if_renamed(val, tbl, key, cache,
				tostring(key):gsub(ptn, repl, nmax))
		end
		for key, val in pairs(cache) do tbl[key] = val end
	end
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|renaming_by_mixing|mixing string|pipe to
library.renaming_by_mixing = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	if ctx.pipe[1] == nil then error(modulename ..
		', ‘renaming_by_mixing’: No mixing string was provided', 0) end
	local mix = ctx.pipe[1]:match'^%s*(.-)%s*$'
	local cache = {}
	local tmp
	if mix == '$@' then
		for _, val in pairs(ctx.params) do
			cache[get_parameter_name(val)] = val
		end
	else
		local skel, canvas, n_parts = parse_placeholder_string(mix)
		for key, val in pairs(ctx.params) do
			for idx = 2, n_parts, 2 do
				if skel[idx] then canvas[idx] = val
				else canvas[idx] = tostring(key) end
			end
			cache[get_parameter_name(table.concat(canvas))] = val
		end
	end
	ctx.params = cache
	return context_iterate(ctx, 2)
end


-- Syntax:  #invoke:params|renaming_to_values|pipe to
--[[
library.renaming_to_values = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local cache = {}
	for _, val in pairs(ctx.params) do cache[val] = val end
	ctx.params = cache
	return context_iterate(ctx, 1)
end
]]--


-- Syntax:  #invoke:params|grouping_by_calling|template
--            name|[let]|[...]|[number of additional arguments]|[argument
--            1]|[argument 2]|[...]|[argument N]|pipe to
library.grouping_by_calling = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local opts = ctx.pipe
	local tmp
	if opts[1] ~= nil then tmp = opts[1]:match'^%s*(.*%S)' end
	if tmp == nil then error(modulename ..
		', ‘grouping_by_calling’: No template name was provided', 0) end
	local model = { title = tmp }
	local tmp, argc = load_child_opts(opts, 2, 0)
	local gargs = {}
	for key, val in pairs(tmp) do
		if type(key) == 'number' and key < 1 then gargs[key - 1] = val
		else gargs[key] = val end
	end
	local groups = make_groups(ctx.params)
	for gid, group in pairs(groups) do
		for key, val in pairs(gargs) do group[key] = val end
		group[0] = gid
		model.args = group
		groups[gid] = ctx.frame:expandTemplate(model)
	end
	ctx.params = groups
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|parsing|string to parse|[trim flag]|[iteration
--            delimiter setter]|[...]|[key-value delimiter setter]|[...]|pipe to
library.parsing = function (ctx)
	local opts = ctx.pipe
	if opts[1] == nil then error(modulename ..
		', ‘parsing’: No string to parse was provided', 0) end
	local isep, iplain, psep, pplain, trimnamed, trimunnamed, argc =
		load_parse_opts(opts, 2, '|', '=')
	parse_parameter_string(ctx.params, opts[1], isep, iplain, psep, pplain,
		trimnamed, trimunnamed)
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|reinterpreting|parameter to reinterpret|[trim
--            flag]|[iteration delimiter setter]|[...]|[key-value delimiter
--            setter]|[...]|pipe to
library.reinterpreting = function (ctx)
	local opts = ctx.pipe
	if opts[1] == nil then error(modulename ..
		', ‘reinterpreting’: No parameter to reinterpret was provided', 0) end
	local isep, iplain, psep, pplain, trimnamed, trimunnamed, argc =
		load_parse_opts(opts, 2, '|', '=')
	local tbl, tmp = ctx.params, get_parameter_name(opts[1])
	local str = tbl[tmp]
	if str ~= nil then
		tbl[tmp] = nil
		parse_parameter_string(tbl, str, isep, iplain, psep, pplain,
			trimnamed, trimunnamed)
	end
	return context_iterate(ctx, argc)
end


-- Syntax:  #invoke:params|evaluating|string to parse|[trim flag]|[iteration
--            delimiter setter]|[...]|[key-value delimiter setter]|[...]|pipe to
library.evaluating = function (ctx)
	-- NOTE: `ctx.pipe` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local opts = ctx.pipe
	if opts[1] == nil then error(modulename ..
		', ‘evaluating’: No string to parse was provided', 0) end
	local isep, iplain, psep, pplain, trimnamed, trimunnamed, argc =
		load_parse_opts(opts, 2, '!', ':')
	if opts[1]:match'^%s*(.*%S)' == nil then
		ctx.pipe = copy_or_ref_table(opts, opts ~= ctx.opipe)
		return context_iterate(ctx, argc)
	end
	local new_opts, cache = {}, {}
	local shift = parse_parameter_string(cache, opts[1], isep, iplain,
		psep, pplain, trimnamed, trimunnamed) - argc
	for key, val in pairs(opts) do
		if type(key) ~= 'number' or key < 1 then new_opts[key] = val
		elseif key >= argc then new_opts[key + shift] = val end
	end
	for key, val in pairs(cache) do new_opts[key] = val end
	ctx.pipe = new_opts
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|mixing_names_and_values|mixing string|pipe to
library.mixing_names_and_values = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	if ctx.pipe[1] == nil then error(modulename ..
		', ‘mixing_names_and_values’: No mixing string was provided for parameter names', 0) end
	if ctx.pipe[2] == nil then error(modulename ..
		', ‘mixing_names_and_values’: No mixing string was provided for parameter values', 0) end
	local cache = {}
	local mix_k, mix_v = ctx.pipe[1]:match'^%s*(.-)%s*$', ctx.pipe[2]
	local tmp
	if mix_k == '$@' and mix_v == '$@' then
		for _, val in pairs(ctx.params) do
			cache[get_parameter_name(val)] = val
		end
	elseif mix_k == '$@' and mix_v == '$#' then
		for key, val in pairs(ctx.params) do
			cache[get_parameter_name(val)] = tostring(key)
		end
	elseif mix_k == '$#' and mix_v == '$#' then
		for _, val in pairs(ctx.params) do cache[key] = tostring(key) end
	else
		local skel_k, cnv_k, n_parts_k = parse_placeholder_string(mix_k)
		local skel_v, cnv_v, n_parts_v = parse_placeholder_string(mix_v)
		for key, val in pairs(ctx.params) do
			tmp = tostring(key)
			for idx = 2, n_parts_k, 2 do
				if skel_k[idx] then cnv_k[idx] = val else cnv_k[idx] = tmp end
			end
			for idx = 2, n_parts_v, 2 do
				if skel_v[idx] then cnv_v[idx] = val else cnv_v[idx] = tmp end
			end
			cache[get_parameter_name(table.concat(cnv_k))] =
				table.concat(cnv_v)
		end
	end
	ctx.params = cache
	return context_iterate(ctx, 3)
end


-- Syntax:  #invoke:params|swapping_names_and_values|pipe to
--[[
library.swapping_names_and_values = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local cache = {}
	for key, val in pairs(ctx.params) do cache[val] = key end
	ctx.params = cache
	return context_iterate(ctx, 1)
end
]]--


-- Syntax:  #invoke:params|combining|new parameter name|[sort order]|setting
--            directives|...|pipe to
library.combining = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	return context_iterate(ctx, combine_parameters(
		ctx,
		function (key, val, kvs) return key .. kvs .. val end,
		'combining'
	) + 1)
end


-- Syntax:  #invoke:params|combining_values|new parameter name|[sort
--            order]|setting directives|...|pipe to
library.combining_values = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	return context_iterate(ctx, combine_parameters(
		ctx,
		function (key, val, kvs) return val end,
		'combining_values'
	) + 1)
end


-- Syntax:  #invoke:params|combining_by_calling|template name|new parameter
--            name|pipe to
library.combining_by_calling = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local tname = ctx.pipe[1]
	if tname ~= nil then tname = tname:match'^%s*(.*%S)'
	else error(modulename ..
		', ‘combining_by_calling’: No template name was provided', 0) end
	if ctx.pipe[2] == nil then error(modulename ..
		', ‘combining_by_calling’: No parameter name was provided', 0) end
	ctx.params = {
		[get_parameter_name(ctx.pipe[2])] = ctx.frame:expandTemplate{
			title = tname,
			args = ctx.params
		}
	}
	return context_iterate(ctx, 3)
end


-- Syntax:  #invoke:params|combining_by_invoking|module name|function name|new
--            parameter name|pipe to
library.combining_by_invoking = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local mname = ctx.pipe[1]
	if mname ~= nil then mname = mname:match'^%s*(.*%S)'
	else error(modulename ..
		', ‘combining_by_invoking’: No module name was provided', 0) end
	local fname = ctx.pipe[2]
	if fname ~= nil then fname = fname:match'^%s*(.*%S)'
	else error(modulename ..
		', ‘combining_by_invoking’: No function name was provided', 0) end
	if ctx.pipe[3] == nil then error(modulename ..
		', ‘combining_by_invoking’: No parameter name was provided', 0) end
	local model = { title = 'Module:' .. mname, args = ctx.params }
	local mfunc = require(model.title)[fname]
	if mfunc == nil then error(modulename ..
		', ‘mapping_by_invoking’: The function ‘' .. fname ..
		'’ does not exist', 0) end
	ctx.params = {
		[get_parameter_name(ctx.pipe[3])] =
			tostring(mfunc(ctx.frame:newChild(model)))
	}
	return context_iterate(ctx, 4)
end


-- Syntax:  #invoke:params|combining_by_magic|parser function|new parameter
--            name|pipe to
library.combining_by_magic = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable! As a modifier,
	-- this function MUST create a copy of it before returning
	local magic = ctx.pipe[1]
	if magic ~= nil then magic = magic:match'^%s*(.*%S)'
	else error(modulename ..
		', ‘combining_by_magic’: No parser function was provided', 0) end
	if ctx.pipe[2] == nil then error(modulename ..
		', ‘combining_by_magic’: No parameter name was provided', 0) end
	ctx.params = {
		[get_parameter_name(ctx.pipe[2])] =
			ctx.frame:callParserFunction(magic, ctx.params)
	}
	return context_iterate(ctx, 3)
end


-- Syntax:  #invoke:params|snapshotting|pipe to
library.snapshotting = function (ctx)
	push_cloned_stack(ctx, ctx.params)
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|remembering|pipe to
library.remembering = function (ctx)
	push_cloned_stack(ctx, ctx.oparams)
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|entering_substack|[new]|pipe to
library.entering_substack = function (ctx)
	local tbl = ctx.params
	local ncurrparent = ctx.n_parents + 1
	if ctx.parents == nil then ctx.parents = { tbl }
	else ctx.parents[ncurrparent] = tbl end
	ctx.n_parents = ncurrparent
	if ctx.pipe[1] ~= nil and ctx.pipe[1]:match'^%s*new%s*$' then
		ctx.params = {}
		return context_iterate(ctx, 2)
	end
	local currsnap = ctx.n_children
	if currsnap > 0 then
		ctx.params = ctx.children[currsnap]
		ctx.children[currsnap] = nil
		ctx.n_children = currsnap - 1
	else
		local newparams = {}
		for key, val in pairs(tbl) do newparams[key] = val end
		ctx.params = newparams
	end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|pulling|parameter name|pipe to
library.pulling = function (ctx)
	local opts = ctx.pipe
	if opts[1] == nil then error(modulename ..
		', ‘pulling’: No parameter to pull was provided', 0) end
	local parent
	local tmp = ctx.n_parents
	if tmp < 1 then parent = ctx.oparams else parent = ctx.parents[tmp] end
	tmp = get_parameter_name(opts[1])
	if parent[tmp] ~= nil then ctx.params[tmp] = parent[tmp] end
	return context_iterate(ctx, 2)
end


-- Syntax:  #invoke:params|detaching_substack|pipe to
library.detaching_substack = function (ctx)
	local ncurrparent = ctx.n_parents
	if ncurrparent < 1 then error(modulename ..
		', ‘detaching_substack’: No substack has been created', 0) end
	local parent = ctx.parents[ncurrparent]
	for key in pairs(ctx.params) do parent[key] = nil end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|dropping_substack|pipe to
library.dropping_substack = function (ctx)
	local ncurrparent = ctx.n_parents
	if ncurrparent < 1 then error(modulename ..
		', ‘dropping_substack’: No substack has been created', 0) end
	ctx.params = ctx.parents[ncurrparent]
	ctx.parents[ncurrparent] = nil
	ctx.n_parents = ncurrparent - 1
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|leaving_substack|pipe to
library.leaving_substack = function (ctx)
	local ncurrparent = ctx.n_parents
	if ncurrparent < 1 then error(modulename ..
		', ‘leaving_substack’: No substack has been created', 0) end
	local currsnap = ctx.n_children + 1
	if ctx.children == nil then ctx.children = { ctx.params }
	else ctx.children[currsnap] = ctx.params end
	ctx.params = ctx.parents[ncurrparent]
	ctx.parents[ncurrparent] = nil
	ctx.n_parents = ncurrparent - 1
	ctx.n_children = currsnap
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|merging_substack|pipe to
library.merging_substack = function (ctx)
	local ncurrparent = ctx.n_parents
	if ncurrparent < 1 then error(modulename ..
		', ‘merging_substack’: No substack has been created', 0) end
	local parent = ctx.parents[ncurrparent]
	local child = ctx.params
	ctx.params = parent
	ctx.parents[ncurrparent] = nil
	ctx.n_parents = ncurrparent - 1
	for key, val in pairs(child) do parent[key] = val end
	return context_iterate(ctx, 1)
end


-- Syntax:  #invoke:params|flushing|pipe to
library.flushing = function (ctx)
	if ctx.n_children < 1 then error(modulename ..
		', ‘flushing’: There are no substacks to flush', 0) end
	local parent = ctx.params
	local currsnap = ctx.n_children
	for key, val in pairs(ctx.children[currsnap]) do parent[key] = val end
	ctx.children[currsnap] = nil
	ctx.n_children = currsnap - 1
	return context_iterate(ctx, 1)
end



	--[[ Functions ]]--
	-----------------------------


-- Syntax:  #invoke:params|count
library.count = function (ctx)
	-- NOTE: `ctx.pipe` and `ctx.params` might be the original metatables!
	local retval = 0
	for _ in ctx.iterfunc(ctx.params) do retval = retval + 1 end
	if ctx.subset == -1 then retval = retval - #ctx.params end
	ctx.text = retval
	return false
end


-- Syntax:  #invoke:args|concat_and_call|template name|[prepend 1]|[prepend 2]
--            |[...]|[item n]|[named item 1=value 1]|[...]|[named item n=value
--            n]|[...]
library.concat_and_call = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable!
	local opts = ctx.pipe
	local tname
	if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end
	if tname == nil then error(modulename ..
		', ‘concat_and_call’: No template name was provided', 0) end
	remove_numeric_keys(opts, 1, 1)
	ctx.text = ctx.frame:expandTemplate{
		title = tname,
		args = concat_params(ctx)
	}
	return false
end


-- Syntax:  #invoke:args|concat_and_invoke|module name|function name|[prepend
--            1]|[prepend 2]|[...]|[item n]|[named item 1=value 1]|[...]|[named
--            item n=value n]|[...]
library.concat_and_invoke = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable!
	local opts = ctx.pipe
	local mname
	local fname
	if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end
	if mname == nil then error(modulename ..
		', ‘concat_and_invoke’: No module name was provided', 0) end
	if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end
	if fname == nil then error(modulename ..
		', ‘concat_and_invoke’: No function name was provided', 0) end
	remove_numeric_keys(opts, 1, 2)
	local mfunc = require('Module:' .. mname)[fname]
	if mfunc == nil then error(modulename ..
		', ‘concat_and_invoke’: The function ‘' .. fname ..
		'’ does not exist', 0) end
	ctx.text = mfunc(ctx.frame:newChild{
		title = 'Module:' .. mname,
		args = concat_params(ctx)
	})
	return false
end


-- Syntax:  #invoke:args|concat_and_magic|parser function|[prepend 1]|[prepend
--            2]|[...]|[item n]|[named item 1=value 1]|[...]|[named item n=
--            value n]|[...]
library.concat_and_magic = function (ctx)
	-- NOTE: `ctx.params` might be the original metatable!
	local opts = ctx.pipe
	local magic
	if opts[1] ~= nil then magic = opts[1]:match'^%s*(.*%S)' end
	if magic == nil then error(modulename ..
		', ‘concat_and_magic’: No parser function was provided', 0) end
	remove_numeric_keys(opts, 1, 1)
	ctx.text = ctx.frame:callParserFunction(magic, concat_params(ctx))
	return false
end


-- Syntax:  #invoke:params|value_of|parameter name
library.value_of = function (ctx)
	-- NOTE: `ctx.pipe` and `ctx.params` might be the original metatables!
	local opts = ctx.pipe
	if opts[1] == nil then error(modulename ..
		', ‘value_of’: No parameter name was provided', 0) end
	local val
	local key = opts[1]:match'^%s*(.-)%s*$'
	if key == '0' or key:find'^%-?[1-9]%d*$' ~= nil then
		key = tonumber(key)
		val = ctx.params[key]
		-- No worries: #ctx.params is unused if the modifier in first position
		if val ~= nil and (
			ctx.subset ~= -1 or key > #ctx.params or key < 1
		) and (
			ctx.subset ~= 1 or (key <= #ctx.params and key > 0)
		) then
			ctx.text = (ctx.header or '') .. val .. (ctx.footer or '')
		else ctx.text = ctx.ifngiven or '' end
	else
		val = ctx.params[key]
		if ctx.subset ~= 1 and val ~= nil then
			ctx.text = (ctx.header or '') .. val .. (ctx.footer or '')
		else ctx.text = ctx.ifngiven or '' end
	end
	return false
end


-- Syntax:  #invoke:params|list
library.list = function (ctx)
	-- NOTE: `ctx.pipe` might be the original metatable!
	local ret, nss, kvs, pps = {}, 0, ctx.pairsep or '', ctx.itersep or ''
	flush_params(
		ctx,
		function (key, val)
			ret[nss + 1] = pps
			ret[nss + 2] = key
			ret[nss + 3] = kvs
			ret[nss + 4] = val
			nss = nss + 4
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 4)
	return false
end


-- Syntax:  #invoke:params|list_values
library.list_values = function (ctx)
	-- NOTE: `ctx.pipe` might be the original metatable!
	-- NOTE: `library.coins()` and `library.unique_coins()` rely on us
	local ret, nss, pps = {}, 0, ctx.itersep or ''
	flush_params(
		ctx,
		function (key, val)
			ret[nss + 1] = pps
			ret[nss + 2] = val
			nss = nss + 2
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|list_maybe_with_names
library.list_maybe_with_names = function (ctx)
	-- NOTE: `ctx.pipe` might be the original metatable!
	local ret, nss, kvs, pps = {}, 0, ctx.pairsep or '', ctx.itersep or ''
	mixed_flush_params(
		ctx,
		function (key, val)
			ret[nss + 1] = pps
			ret[nss + 2] = ''
			ret[nss + 3] = ''
			ret[nss + 4] = val
			nss = nss + 4
		end,
		function (key, val)
			ret[nss + 1] = pps
			ret[nss + 2] = key
			ret[nss + 3] = kvs
			ret[nss + 4] = val
			nss = nss + 4
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 4)
	return false
end


-- Syntax:  #invoke:params|coins|[first coin = value 1]|[second coin = value
--            2]|[...]|[last coin = value N]
library.coins = function (ctx)
	-- NOTE: `ctx.pipe` might be the original metatable!
	local opts, tbl = ctx.pipe, ctx.params
	for key, val in pairs(tbl) do tbl[key] = opts[get_parameter_name(val)] end
	return library.list_values(ctx)
end


-- Syntax:  #invoke:params|unique_coins|[first coin = value 1]|[second coin =
--            value 2]|[...]|[last coin = value N]
library.unique_coins = function (ctx)
	local opts, tbl = ctx.pipe, ctx.params
	local tmp
	for key, val in pairs(tbl) do
		tmp = get_parameter_name(val)
		tbl[key] = opts[tmp]
		opts[tmp] = nil
	end
	return library.list_values(ctx)
end


-- Syntax:  #invoke:params|for_each|wikitext
library.for_each = function (ctx)
	-- NOTE: `ctx.pipe` might be the original metatable!
	local ret, nss, pps, txt = {}, 0, ctx.itersep or '', ctx.pipe[1] or ''
	local skel, cnv, n_parts = parse_placeholder_string(txt)
	flush_params(
		ctx,
		function (key, val)
			for idx = 2, n_parts, 2 do
				if skel[idx] then cnv[idx] = val
				else cnv[idx] = tostring(key) end
			end
			ret[nss + 1] = pps
			ret[nss + 2] = table.concat(cnv)
			nss = nss + 2
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|call_for_each|template name|[append 1]|[append 2]
--            |[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
library.call_for_each = function (ctx)
	local opts = ctx.pipe
	local tname
	if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end
	if tname == nil then error(modulename ..
		', ‘call_for_each’: No template name was provided', 0) end
	local model = { title = tname, args = opts }
	local ret, nss, ccs = {}, 0, ctx.itersep or ''
	table.insert(opts, 1, true)
	flush_params(
		ctx,
		function (key, val)
			opts[1] = key
			opts[2] = val
			ret[nss + 1] = ccs
			ret[nss + 2] = ctx.frame:expandTemplate(model)
			nss = nss + 2
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|invoke_for_each|module name|module function|[append
--            1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]
--            |[named param n=value n]|[...]
library.invoke_for_each = function (ctx)
	local opts = ctx.pipe
	local mname
	local fname
	if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end
	if mname == nil then error(modulename ..
		', ‘invoke_for_each’: No module name was provided', 0) end
	if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end
	if fname == nil then error(modulename ..
		', ‘invoke_for_each’: No function name was provided', 0) end
	local model = { title = 'Module:' .. mname, args = opts }
	local mfunc = require(model.title)[fname]

	local ret, nss, ccs = {}, 0, ctx.itersep or ''
	flush_params(
		ctx,
		function (key, val)
			opts[1] = key
			opts[2] = val
			ret[nss + 1] = ccs
			ret[nss + 2] = mfunc(ctx.frame:newChild(model))
			nss = nss + 2
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|magic_for_each|parser function|[append 1]|[append 2]
--            |[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
library.magic_for_each = function (ctx)
	local opts = ctx.pipe
	local magic
	if opts[1] ~= nil then magic = opts[1]:match'^%s*(.*%S)' end
	if magic == nil then error(modulename ..
		', ‘magic_for_each’: No parser function was provided', 0) end
	local ret, nss, ccs = {}, 0, ctx.itersep or ''
	table.insert(opts, 1, true)
	flush_params(
		ctx,
		function (key, val)
			opts[1] = key
			opts[2] = val
			ret[nss + 1] = ccs
			ret[nss + 2] = ctx.frame:callParserFunction(magic, opts)
			nss = nss + 2
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|call_for_each_value|template name|[append 1]|[append
--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
library.call_for_each_value = function (ctx)
	local opts = ctx.pipe
	local tname
	if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end
	if tname == nil then error(modulename ..
		', ‘call_for_each_value’: No template name was provided', 0) end
	local model = { title = tname, args = opts }
	local ret, nss, ccs = {}, 0, ctx.itersep or ''
	flush_params(
		ctx,
		function (key, val)
			opts[1] = val
			ret[nss + 1] = ccs
			ret[nss + 2] = ctx.frame:expandTemplate(model)
			nss = nss + 2
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|invoke_for_each_value|module name|[append 1]|[append
--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
library.invoke_for_each_value = function (ctx)
	local opts = ctx.pipe
	local mname
	local fname
	if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end
	if mname == nil then error(modulename ..
		', ‘invoke_for_each_value’: No module name was provided', 0) end
	if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end
	if fname == nil then error(modulename ..
		', ‘invoke_for_each_value’: No function name was provided', 0) end
	local model = { title = 'Module:' .. mname, args = opts }
	local mfunc = require(model.title)[fname]
	local ret, nss, ccs = {}, 0, ctx.itersep or ''
	remove_numeric_keys(opts, 1, 1)
	flush_params(
		ctx,
		function (key, val)
			opts[1] = val
			ret[nss + 1] = ccs
			ret[nss + 2] = mfunc(ctx.frame:newChild(model))
			nss = nss + 2
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|magic_for_each_value|parser function|[append 1]
--            |[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named
--            param n=value n]|[...]
library.magic_for_each_value = function (ctx)
	local opts = ctx.pipe
	local magic
	if opts[1] ~= nil then magic = opts[1]:match'^%s*(.*%S)' end
	if magic == nil then error(modulename ..
		', ‘magic_for_each_value’: No parser function was provided', 0) end
	local ret, nss, ccs = {}, 0, ctx.itersep or ''
	flush_params(
		ctx,
		function (key, val)
			opts[1] = val
			ret[nss + 1] = ccs
			ret[nss + 2] = ctx.frame:callParserFunction(magic, opts)
			nss = nss + 2
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end


-- Syntax:  #invoke:params|call_for_each_group|template name|[append 1]|[append
--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
library.call_for_each_group = function (ctx)
	-- NOTE: `ctx.pipe` and `ctx.params` might be the original metatables!
	local opts = ctx.pipe
	local tmp
	if opts[1] ~= nil then tmp = opts[1]:match'^%s*(.*%S)' end
	if tmp == nil then error(modulename ..
		', ‘call_for_each_group’: No template name was provided', 0) end
	local model = { title = tmp }
	local opts, ret, nss, ccs = {}, {}, 0, ctx.itersep or ''
	for key, val in pairs(ctx.pipe) do
		if type(key) == 'number' then opts[key - 1] = val
		else opts[key] = val end
	end
	ctx.pipe = opts
	ctx.params = make_groups(ctx.params)
	flush_params(
		ctx,
		function (gid, group)
			for key, val in pairs(opts) do group[key] = val end
			group[0] = gid
			model.args = group
			ret[nss + 1] = ccs
			ret[nss + 2] = ctx.frame:expandTemplate(model)
			nss = nss + 2
		end
	)
	finalize_and_return_concatenated_list(ctx, ret, nss, 2)
	return false
end



	---                                        ---
	---     PUBLIC ENVIRONMENT                 ---
	---    ________________________________    ---
	---                                        ---



	--[[ First-position-only modifiers ]]--
	---------------------------------------


-- Syntax:  #invoke:params|new|pipe to
static_iface.new = function (child_frame)
	local ctx = context_new(child_frame)
	ctx.pipe = copy_or_ref_table(ctx.opipe, false)
	ctx.params = {}
	main_loop(ctx, context_iterate(ctx, 1))
	return ctx.text
end



	--[[ First-position-only functions ]]--
	---------------------------------------


-- Syntax:  #invoke:params|self
static_iface.self = function (frame)
	return frame:getParent():getTitle()
end



	--[[ Public metatable of functions ]]--
	---------------------------------------


return setmetatable({}, {
	__index = function (_, query)
		local fname = query:match'^%s*(.*%S)'
		if fname == nil then error(modulename ..
			': You must specify a function to call', 0) end
		local func = static_iface[fname]
		if func ~= nil then return func end
		func = library[fname]
		if func == nil then error(modulename ..
			': The function ‘' .. fname .. '’ does not exist', 0) end
		return function (child_frame)
			local ctx = context_new(child_frame)
			ctx.pipe = copy_or_ref_table(ctx.opipe, refpipe[fname])
			ctx.params = copy_or_ref_table(ctx.oparams, refparams[fname])
			main_loop(ctx, func)
			return ctx.text
		end
	end
})

[1] To be precise, the order will not be strictly alphabetical, because this would imply that a template called with the following parameters {{foobar|-4=you|9=wanna|.=me?|11=marry|-8=do}} would see them reordered as follows: {{foobar|-8=do|-4=you|.=me?|9=wanna|11=marry}} (with the dot in the middle between negative and positive numbers). To avoid this, numbers are always displayed first (i.e. {{foobar|-8=do|-4=you|9=wanna|11=marry|.=me?}}).

[2] Unless followed by renaming_by_replacing in few bizarre situations, there is virtually no use in calling this modifier more than once.

[1]

[2]

Before calling `filling_the_gaps`	After calling `filling_the_gaps`
`\|1=...`	`\|1=...`
`\|2=...`	`\|1=`, `\|2=...`
`\|6=...`, `\|9=...`	`\|1=`, `\|2=`, `\|3=`, `\|4=`, `\|5=`, `\|6=...`, `\|7=`, `\|8=`, `\|9=...`
`\|-5=...`, `\|-3=...`	`\|-5=...`, `\|-4=`, `\|-3=...`
`\|-5=...`, `\|-3=...`, `\|1=...`	`\|-5=...`, `\|-4=`, `\|-3=...`, `\|-2=`, `\|-1=`, `\|0=`, `\|1=...`
`\|-1=...`	`\|-1=...`
`\|-2=...`	`\|-2=...`

Call style flag	Example	Corresponding call
`names_and_values`	`{{#invoke:params\|mapping_by_calling\|example template\|names_and_values\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|NAME\|VALUE\|hello\|world\|foo=bar}}`
`values_and_names`	`{{#invoke:params\|mapping_by_calling\|example template\|values_and_names\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|VALUE\|NAME\|hello\|world\|foo=bar}}`
`names_only`	`{{#invoke:params\|mapping_by_calling\|example template\|names_only\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|NAME\|hello\|world\|foo=bar}}`
`values_only`	`{{#invoke:params\|mapping_by_calling\|example template\|values_only\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|VALUE\|hello\|world\|foo=bar}}`
`names_and_values_as\|...\|...`	`{{#invoke:params\|mapping_by_calling\|example template\|names_and_values_as\|my_name\|my_value\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|hello\|world\|my_name=NAME\|my_value=VALUE\|foo=bar}}`
`names_only_as\|...`	`{{#invoke:params\|mapping_by_calling\|example template\|names_only_as\|my_name\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|hello\|world\|my_name=NAME\|foo=bar}}`
`values_only_as\|...`	`{{#invoke:params\|mapping_by_calling\|example template\|values_only_as\|my_value\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|hello\|world\|my_value=VALUE\|foo=bar}}`
`blindly`	`{{#invoke:params\|mapping_by_calling\|example template\|blindly\|let\|foo\|bar\|2\|hello\|world\|setting\|i/p\|<br />\| → \|list}}`	`{{example template\|hello\|world\|foo=bar}}`