View source for Module:Params/doc

<!-- Add categories where indicated at the bottom of this page and interwikis at Wikidata -->
{{Module rating|release}}
{{module:params/doc/main sidebox}}

The <syntaxhighlight lang="wikitext" inline>{{#invoke:params}}</syntaxhighlight> module is designed to be adopted by templates that require fine-grained control over their parameters. It is particularly useful for [[:w:en:variadic template|variadic template]]s, to which it offers the ability to count, list, map, and propagate the parameters they receive without knowing their number in advance.

The module also offers elegant shortcuts for non-variadic templates. Outside templates, however, it has very few applications; therefore, if you plan to experiment with it, make sure to do so from within a template, or you will not be able to see much (you can use {{[[Module:Params/testcases/sandbox]]}} for that).

Under [[Module:Params/testcases|./testcases]] you can find helper templates specifically intended for testing the module's capabilities in flexible ways. Finally, under [[Module:Params/doc/examples|./doc/examples]] you can find some of the examples shown throughout this documentation page.

{{Note}} If your template uses <syntaxhighlight lang="wikitext" inline>{{#invoke:params}}</syntaxhighlight>, please add <syntaxhighlight lang="wikitext" inline>{{lua|Module:Params}}</syntaxhighlight> to its documentation page, so that if breaking changes are introduced in the future, the template can be easily traced without performing <span class="plainlinks">[//en.wikipedia.org/w/index.php?search=insource%3A%2Finvoke%3Aparams%2Fi&title=Special%3ASearch&profile=advanced&fulltext=1&ns10=1&limit=500&sort=last_edit_desc an "in-source" search]</span>.

Please do not edit this module without first carrying out extensive testing in the [[Module:Params/sandbox|module's sandbox]].

== General usage ==
Among the possibilities that the module offers 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 free from interference, instead of named arguments in order to specify options this module uses ''piping functions'' (i.e. functions that expect to be [[:w:en:Pipeline (software)|piped]] instead of returning to the caller), or ''modifiers''. This creates a syntax similar to the following example:

<syntaxhighlight lang="wikitext">{{#invoke:params|[modifier]|[...]|[modifier]|[...]|function|[...]}}</syntaxhighlight>

For instance, as its name suggests, the <code>[[#list|list]]</code> 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 stuck to each other. However, by using the <code>[[#setting|setting]]</code> modifier, we are able to declare a key-value delimiter (<code>p</code>) and an iteration delimiter (<code>i</code>). Thus, if we imagine a template named <syntaxhighlight lang="wikitext" inline>{{example template}}</syntaxhighlight> containing the following wikitext,

<syntaxhighlight lang="wikitext">{{#invoke:params|setting|i/p|<br />|: |list}}</syntaxhighlight>

and suppose that the template is called with the following parameters,

<syntaxhighlight lang="wikitext">{{example template
	| Beast of Bodmin = A large feline inhabiting Bodmin Moor
	| Morgawr = A sea serpent
	| Owlman = A giant owl-like creature
}}</syntaxhighlight>

the following result is produced:

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

We can also do more sophisticated things; for instance, by exploiting the possibility of setting a header (<code>h</code>) and a footer (<code>f</code>), we can transform the previous code into a generator of [https://html.spec.whatwg.org/multipage/grouping-content.html#the-dl-element definition lists],

<syntaxhighlight lang="wikitext">{{#invoke:params|setting|h/p/i/f|<dl><dt>|</dt><dd>|</dd><dt>|</dd></dl>|list}}</syntaxhighlight>

thus yielding:

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

By placing the <code>[[#with_name_matching|with_name_matching]]</code> modifier before the <code>[[#list|list]]</code> function, we are able to filter some parameters out—for instance, all parameter names that do not end with an "n":

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

Thus, the previous code produces:

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

This mechanism has the intrinsic advantage of allowing an arbitrary number of modifiers to be concatenated. Thus, in order to obtain exactly the result we want, we can write:

<syntaxhighlight lang="wikitext">{{#invoke:params|
	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>|
	all_sorted|
	list
}}</syntaxhighlight>

Conceptually, the parameter collection flows through a pipeline in which each modifier transforms the result produced by the previous step.

Since it is a wikitext-oriented module focused on manipulating collections, its functions and modifiers have loosely been inspired by JavaScript <code>Array</code>'s [https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#instance_methods instance methods].<ref>For instance, <code>[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map Array.prototype.map()]</code> can resemble <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach Array.prototype.forEach()]</code> can resemble <code>[[#call_for_each_value|call_for_each_value]]</code>, <code>[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice Array.prototype.splice()]</code> can resemble <code>[[#splicing|splicing]]</code>, <code>[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/with Array.prototype.with()]</code> can resemble <code>[[#entering_substack|entering_substack]]&#124;...&#124;[[#merging_substack|merging_substack]]</code>, and so on.</ref> The syntax that emerges from piping functions to one another instead results similar to [[:w:en:jQuery#Chaining|jQuery's method chains]]. In that sense, this

<syntaxhighlight lang="javascript">$("#myElement")
	.css("background-color", "blue")
	.addClass("active")
	.hide()
	.etc...</syntaxhighlight>

might loosely resemble this:

<syntaxhighlight lang="wikitext">{{#invoke:params|
	excluding_non-numeric_names|
	mapping_by_replacing|[^abdlp]+||
	mapping_by_replacing|a|⏒ ||plain|
	etc...
}}</syntaxhighlight>

Conceptually, the pattern is very similar: each step transforms the result of the previous one. However, instead of a jQuery object being manipulated indefinitely, what is manipulated here is always a collection of wikitext parameters.

At any point during execution, Params maintains an internal list of parameters known as the '''pipeline'''. Modifiers transform this pipeline step by step, while functions inspect it or convert it into the final output. Unless otherwise stated, each modifier transforms the current pipeline and passes the result to the next directive. Besides the main pipeline, Params can temporarily work on nested pipelines called '''substacks'''. A substack initially contains a copy (or a filtered copy) of the current pipeline and can then be processed independently before being merged back, detached, or discarded, depending on the modifier used.

=== Considerations on code style ===
Normally on Wikipedia, when templates are written across multiple lines in ''block style'', the convention is to write the pipe sign (<code>&#124;</code>) on the left-hand side of each new line, as in the following example:

<syntaxhighlight lang="wikitext">{{cite book
	| last = Bloggs
	| first = Joe
	| author-link = Joe Bloggs
	| date = 1974
	| title = Book of Bloggs
}}</syntaxhighlight>

Doing the same with <syntaxhighlight lang="wikitext" inline>{{#invoke:params}}</syntaxhighlight> however is often impossible, because the module tends to preserve trailing spaces and newlines in all its arguments except modifier and function names (and, accordingly, a newline character would be parsed as belonging to the last parameter on 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, immediately before a modifier name or a function name'', as in the following example:

<syntaxhighlight lang="wikitext">{{#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
}}</syntaxhighlight>

=== 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 directly 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 <syntaxhighlight lang="wikitext" inline><includeonly>...</includeonly></syntaxhighlight> and <syntaxhighlight lang="wikitext" inline><noinclude>...</noinclude></syntaxhighlight> tags properly to include the template's transclusion as well, the second approach consists in temporarily relying on the <code>[[#imposing|imposing]]</code> modifier.

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

<syntaxhighlight lang="wikitext"><includeonly>{{#invoke:params|value_of|foo}}</includeonly><noinclude>{{{{#invoke:params|self}}|one|two|three|foo=bar}}</noinclude></syntaxhighlight>

or, equivalently,

<syntaxhighlight lang="wikitext">{{#invoke:params|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|foo|bar|
	value_of|foo
}}</syntaxhighlight>

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

<syntaxhighlight lang="wikitext"><includeonly>{{#invoke:params|value_of|foo}}</includeonly><noinclude>{{Documentation}}</noinclude></syntaxhighlight>

Here are some suggestions on how to proceed in order to master this module:
# Start by using only the <code>[[#list|list]]</code>, <code>[[#list_values|list_values]]</code> and <code>[[#for_each|for_each]]</code> functions
# Learn how to use the <code>[[#setting|setting]]</code> modifier
# Learn how to use all the other modifiers
# Learn how to use all the other functions

=== Nomenclature and conventions ===
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|functions]] behave (e.g. <code>[[#sequential|sequential]]</code>, <code>[[#non-sequential|non-sequential]]</code>, <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code> – as the only action they do consists in ''placing a flag'', these are called “[[#Flag modifiers (piping functions)|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 modifiers (piping functions)|flag modifier]] (e.g. <code>[[#sequential|sequential]]</code>)
* If a directive is or contains an English [[:w:en:gerundive|gerundive]] it is a [[#Modifiers (piping functions)|modifier]] (with the exception of the special, first-position-only <code>[[#new|new]]</code> directive – e.g. <code>[[#squeezing|squeezing]]</code>)
* If a directive is anything else (usually an English [[:w:en:bare infinitive|bare infinitive]]) it is a normal non-piping [[#Functions|function]] (e.g. <code>[[#list_values|list_values]]</code>)

Several modifiers start with the same prefix. If you are familiar with computing, the following analogies may be helpful:

* <code>with_*</code> operations are generally [[:w:Filter (higher-order function)|filters]].
* <code>combining_*</code> operations are generally [[:w:Fold (higher-order function)|reductions]].
* <code>mapping_*</code> operations are generally [[:w:Map (higher-order function)|maps]] over parameter values.
* <code>renaming_*</code> operations are generally [[:w:Map (higher-order function)|maps]] over parameter names.

The two flag modifiers <code>[[#sequential|sequential]]</code> and <code>[[#non-sequential|non-sequential]]</code> 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 {{para|1}} – this is known as the parameters' "sequence". A parameter list that does not have a first parameter specified does not possess a sequence.

When an operation performs string substitution, the special placeholders <code>$#</code> and <code>$@</code> represent the current parameter's name and value, respectively.

== Functions ==

Here follows the list of functions. You might want to see also [[#Flag modifiers (piping functions)|§ Flag modifiers]] and [[#Modifiers (piping functions)|§ Modifiers]].

<div style="width: 100%; height: 1em;"></div>

=== <code>self</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>self</code> <span style="nowrap">({{module:params/doc/link to the code|self|code}})</span>
	| Num. of arguments: 0
	| Not affected by: Any modifier
	| ; See also
	| : <code>{{mfl|TEMPLATENAME|main}}</code>, <code>{{Magic word|FULLPAGENAME}}</code>
}}

; Brief
: ''Return the name of the current template''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|self}}</syntaxhighlight>

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 <code>Page X</code> contained only a transclusion of a template named <syntaxhighlight lang="wikitext" inline>{{foobar}}</syntaxhighlight>, and the latter contained the following wikitext,

<syntaxhighlight lang="wikitext">{{#invoke:params|self}}

{{FULLPAGENAME}}</syntaxhighlight>

if we visited <code>Template:Foobar</code> we would see,

<pre>Template:Foobar

Template:Foobar</pre>

whereas if we visited <code>Page X</code> we would see:

<pre>Template:Foobar

Page X</pre>

Therefore by writing

<syntaxhighlight lang="wikitext">{{#ifeq:{{#invoke:params|self}}|{{FULLPAGENAME}}
	| Page is not being transcluded
	| Page is being transcluded
}}</syntaxhighlight>

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

If <code>Page X</code> transcluded <syntaxhighlight lang="wikitext" inline>{{foobar 2}}</syntaxhighlight> and the latter were a redirect to <syntaxhighlight lang="wikitext" inline>{{foobar}}</syntaxhighlight>, we would still see

<pre>Template:Foobar

Page X</pre>

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

<syntaxhighlight lang="wikitext">{{edit|{{#invoke:params|self}}|edit this template}}</syntaxhighlight>

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

<syntaxhighlight lang="wikitext">{{{{#invoke:params|self}}/my subtemplate|foo|bar}}</syntaxhighlight>

<div style="width: 100%; height: 1.5em;"></div>

=== <code>count</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>count</code> <span style="nowrap">({{module:params/doc/link to the code|count|code}})</span>
	| Num. of arguments: 0
	| Often preceeded by: <code>[[#sequential|sequential]]</code>
	| Not affected by: <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code>, <code>[[#setting|setting]]</code>,<br /><code>[[#sorting_sequential_values|sorting_sequenti…]]</code>,<br /><code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoki…]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#mapping_by_replacing|mapping_by_replac…]]</code>
	| ; See also
	| : <code>[[#scoring|scoring]]</code>, <code>{{ml|ParameterCount}}</code>
}}

; Brief
: ''Count the number of parameters wherewith a template was called''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|count}}</syntaxhighlight>

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,

<syntaxhighlight lang="wikitext" inline>{{#invoke:params|count}}</syntaxhighlight>

and

<syntaxhighlight lang="wikitext" inline>{{#invoke:params|sequential|count}}</syntaxhighlight>

will return different results.

For the modifier version of this function, see <code>[[#scoring|scoring]]</code>.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>concat_and_call</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>concat_and_call</code> <span style="nowrap">({{module:params/doc/link to the code|concat_and_call|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Not affected by: <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code>
	| ; See also
	| : <code>[[#combining|combining]]</code>, <code>[[#combining_values|combining_values]]</code>, <code>[[#combining_by_calling|combining_by_calling]]</code>, <code>[[#combining_by_invoking|combining_by_invoking]]</code>, <code>[[#combining_by_magic|combining_by_magic]]</code>, <code>[[#concat_and_invoke|concat_and_invoke]]</code>, <code>[[#concat_and_magic|concat_and_magic]]</code>, <code>{{mfl|template wrapper|wrap}}</code>
}}

; 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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|concat_and_call|template name|[prepend 1]|[prepend 2]|[...]|[prepend n]|[named item 1=value 1]|[...]|[named item n=value n]|[...]}}</syntaxhighlight>

This function comes in handy in case of [[:w:en:Wikipedia:Wrapper templates|wrapper templates]]. For example, if our <syntaxhighlight lang="wikitext" inline>{{wrapper template}}</syntaxhighlight> had the following code,

<syntaxhighlight lang="wikitext">{{#invoke:params|concat_and_call|foobar|elbow|earth|room|hello=not today}}</syntaxhighlight>

and were called with,

<syntaxhighlight lang="wikitext">{{wrapper template|one|two|three|hello=world|wind=spicy}}</syntaxhighlight>

the following call to the <syntaxhighlight lang="wikitext" inline>{{foobar}}</syntaxhighlight> template would be performed:

<syntaxhighlight lang="wikitext">{{foobar|elbow|earth|room|one|two|three|hello=not today|wind=spicy}}</syntaxhighlight>

By using the <code>[[#cutting|cutting]]</code> modifier it is possible to impose numeric positive parameters instead of prepending them. For instance, the following code echoes all incoming parameters to <syntaxhighlight lang="wikitext" inline>{{my template}}</syntaxhighlight>, with the exception of {{para|3}}, which is replaced with <code>hello world</code>:

<syntaxhighlight lang="wikitext">{{#invoke:params|cutting|3|0|concat_and_call|my template|{{{1|}}}|{{{2|}}}|hello world}}</syntaxhighlight>

If the numeric parameters to replace are a limited number, as in the example above, a better alternative to <code>[[#cutting|cutting]]</code> might be <code>[[#imposing|imposing]]</code>:

<syntaxhighlight lang="wikitext">{{#invoke:params|imposing|3|hello world|concat_and_call|my template}}</syntaxhighlight>

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

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this function except the ''template name'' will not be trimmed of their leading and trailing spaces. The <code>concat_and_call</code> ''function name'' itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>concat_and_invoke</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>concat_and_invoke</code> <span style="nowrap">({{module:params/doc/link to the code|concat_and_invoke|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Not affected by: <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code>
	| ; See also
	| : <code>[[#concat_and_call|concat_and_call]]</code>, <code>[[#concat_and_magic|concat_and_magic]]</code>
}}

; 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
: <syntaxhighlight lang="wikitext" inline>{{#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]|[...]}}</syntaxhighlight>

Exactly like <code>[[#concat_and_call|concat_and_call]]</code>, but invokes a module function instead of calling a template.

<div style="width: 100%; height: 1em;"></div>

{{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 <code>concat_and_invoke</code> ''function name'' itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>concat_and_magic</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>concat_and_magic</code> <span style="nowrap">({{module:params/doc/link to the code|concat_and_magic|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Not affected by: <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code>
	| ; See also
	| : <code>[[#concat_and_call|concat_and_call]]</code>, <code>[[#concat_and_invoke|concat_and_invoke]]</code>
}}

; 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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|concat_and_magic|parser function|[prepend 1]|[prepend 2]|[...]|[prepend n]|[named item 1=value 1]|[...]|[named item n=value n]|[...]}}</syntaxhighlight>

Exactly like <code>[[#concat_and_call|concat_and_call]]</code>, but calls a [[:w:en::mw:Help:Magic words#Parser functions|parser function]] instead of a template.

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this function except the magic word will not be trimmed of their leading and trailing spaces. The <code>concat_and_magic</code> ''function name'' itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>value_of</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>value_of</code> <span style="nowrap">({{module:params/doc/link to the code|value_of|code}})</span>
	| Num. of arguments: 1
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>f</code>, <code>n</code>
	| Not affected by: <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code>
	| ; See also
	| : <code>[[#list_values|list_values]]</code>, <code>[[#list_maybe_with_names|list_maybe_with_names]]</code><!--, <code>[[#coins|coins]]</code>, <code>[[#unique_coins|unique_coins]]</code>-->
}}

; Brief
: ''Get the value of a single parameter''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|value_of|parameter name}}</syntaxhighlight>

Without modifiers this function is similar to writing <syntaxhighlight lang="wikitext" inline>{{{parameter name|}}}</syntaxhighlight>. With modifiers, however, it allows reaching parameters that would be unreachable without knowing their number in advance. For instance, writing

<syntaxhighlight lang="wikitext">{{#invoke:params|cutting|-2|0|value_of|1}}</syntaxhighlight>

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 (<code>h</code>), a footer (<code>f</code>), and a fallback text (<code>n</code>) can be declared via the <code>[[#setting|setting]]</code> modifier – the strings assigned to the key-value pair delimiter (<code>p</code>), the iteration delimiter (<code>i</code>), the last iteration delimiter (<code>l</code>) and the "serial-comma-like" last iteration delimiter (<code>s</code>) will be ignored.

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

<syntaxhighlight lang="wikitext">{{#invoke:params|with_value_not_matching|^%s*$|setting|h/f/n|{{{3|}}}|{{{4|}}}|{{{2|}}}|value_of|1}}</syntaxhighlight>

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

<syntaxhighlight lang="wikitext">{{#invoke:params|with_value_not_matching||strict|squeezing|value_of|1}}</syntaxhighlight>

Whereas the following wikitext expands to the first parameter that is not blank (i.e. neither empty nor containing only [[:w:en:whitespace|whitespace]]s)

<syntaxhighlight lang="wikitext">{{#invoke:params|with_value_not_matching|^%s*$|squeezing|value_of|1}}</syntaxhighlight>

<div style="width: 100%; height: 1.5em;"></div>

=== <code>list</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>list</code> <span style="nowrap">({{module:params/doc/link to the code|list|code}})</span>
	| Num. of arguments: 0
	| [[#all_sorted|Sortable]]: Yes
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>p</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#list_values|list_values]]</code>, <code>[[#list_maybe_with_names|list_maybe_with_names]]</code>
}}

; Brief
: ''List the template parameters (both their names and their values)''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|list}}</syntaxhighlight>

This function does not take arguments.

If the <code>[[#setting|setting]]</code> 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 (<code>h</code>), a key-value pair delimiter (<code>p</code>), an iteration delimiter (<code>i</code>), a last iteration delimiter (<code>l</code>), a "[[:w:en:serial comma|serial-comma]]-like" last iteration delimiter (<code>s</code>), a footer (<code>f</code>), and a fallback text (<code>n</code>) can be declared via <code>[[#setting|setting]]</code>.

For example, the following code

<syntaxhighlight lang="wikitext">{{#invoke:params|setting|h/i/p/f/n|'''Parameters passed:''' |); | (|)|'''No parameters were passed'''|list}}</syntaxhighlight>

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)

<div style="width: 100%; height: 1.5em;"></div>

=== <code>list_values</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>list_values</code> <span style="nowrap">({{module:params/doc/link to the code|list_values|code}})</span>
	| Num. of arguments: 0
	| [[#all_sorted|Sortable]]: Yes
	| Often preceeded by: <code>[[#sequential|sequential]]</code>
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#list|list]]</code>, <code>[[#list_maybe_with_names|list_maybe_with_names]]</code>, <code>[[#value_of|value_of]]</code><!--, <code>[[#coins|coins]]</code>, <code>[[#unique_coins|unique_coins]]</code>-->, <code>{{ml|separated entries}}</code>
}}

; Brief
: ''List the values of the incoming parameters''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|list_values}}</syntaxhighlight>

This function does not take arguments.

The <code>[[#sequential|sequential]]</code> modifier often accompanies this function. If the <code>[[#setting|setting]]</code> 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 (<code>h</code>), an iteration delimiter (<code>i</code>), a last iteration delimiter (<code>l</code>), a "[[:w:en:serial comma|serial-comma]]-like" last iteration delimiter (<code>s</code>), a footer (<code>f</code>), and a fallback text (<code>n</code>) can be declared via <code>[[#setting|setting]]</code> – the string assigned to the key-value pair delimiter (<code>p</code>) will be ignored.

For example, the following code

<syntaxhighlight lang="wikitext">{{#invoke:params|setting|h/i/f/n|'''Values of parameters passed:''' |; |.|'''No parameters were passed'''|list_values}}</syntaxhighlight>

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 {{mfl|Separated entries|main}}. For instance, the following two examples with “ + ” as delimiter and “ ... ” as conjunction produce a similar result:

# <syntaxhighlight lang="wikitext" inline>{{#invoke:separated entries|main|separator=&#32;+&#32;|conjunction=&#32;...&#32;}}</syntaxhighlight>
# <syntaxhighlight lang="wikitext" inline>{{#invoke:params|sequential|trimming_values|with_value_not_matching||strict|squeezing|setting|i/l| + | ... |list_values}}</syntaxhighlight>

<div style="width: 100%; height: 1.5em;"></div>

=== <code>list_maybe_with_names</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>list_maybe_with_names</code> <span style="nowrap">({{module:params/doc/link to the code|list_maybe_with_names|code}})</span>
	| Num. of arguments: 0
	| [[#all_sorted|Sortable]]: Yes
	| Often preceeded by: <code>[[#sequential|sequential]]</code>
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#list|list]]</code>, <code>[[#list_values|list_values]]</code>, <code>[[#value_of|value_of]]</code><!--, <code>[[#coins|coins]]</code>, <code>[[#unique_coins|unique_coins]]</code>-->, <code>{{ml|separated entries}}</code>
}}

; Brief
: ''List the values of sequential parameters and the names and the values of non-sequential parameters''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|list_maybe_with_names}}</syntaxhighlight>

This function does not take arguments. It is a combination of <code>[[#list|list]]</code> and <code>[[#list_values|list_values]]</code>: 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 <code>[[#setting|setting]]</code> 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 (<code>h</code>), a key-value pair delimiter (<code>p</code>), an iteration delimiter (<code>i</code>), a last iteration delimiter (<code>l</code>), a "[[:w:en:serial comma|serial-comma]]-like" last iteration delimiter (<code>s</code>), a footer (<code>f</code>), and a fallback text (<code>n</code>) can be declared via <code>[[#setting|setting]]</code>.

For example, the following code in <syntaxhighlight lang="wikitext" inline>{{My template}}</syntaxhighlight>,

<syntaxhighlight lang="wikitext">{{#invoke:params|setting|h/i/p/f/n|'''Parameters passed:''' |; |→|.|'''No parameters were passed'''|list_maybe_with_names}}</syntaxhighlight>

when transcluded as <syntaxhighlight lang="wikitext" inline>{{My template|one|two|three|four|foo=bar|hello=world}}</syntaxhighlight>, 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.

<div style="width: 100%; height: 1.5em;"></div>
<!--
=== <code>coins</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>coins</code> <span style="nowrap">({{module:params/doc/link to the code|coins|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| [[#all_sorted|Sortable]]: Yes
	| Often preceeded by: <code>[[#sequential|sequential]]</code>, <code>[[#trimming_values|trimming_values]]</code>
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#unique_coins|unique_coins]]</code>, <code>[[#list_values|list_values]]</code>, <code>[[#value_of|value_of]]</code>
}}

; Brief
: ''Associate custom strings to possible parameter values and list the custom string when the associated value is present''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|coins|[first coin = value 1]|[second coin = value 2]|[...]|[last coin = value N]}}</syntaxhighlight>

This function is identical to the <code>[[#unique_coins|unique_coins]]</code> function, except that it allows the repetition of identical flags. See there for more information.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>unique_coins</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>unique_coins</code> <span style="nowrap">({{module:params/doc/link to the code|unique_coins|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| [[#all_sorted|Sortable]]: Yes
	| Often preceeded by: <code>[[#sequential|sequential]]</code>, <code>[[#trimming_values|trimming_values]]</code>
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#coins|coins]]</code>, <code>[[#list_values|list_values]]</code>, <code>[[#value_of|value_of]]</code>
}}

; 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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|unique_coins|[first coin = value 1]|[second coin = value 2]|[...]|[last coin = value N]}}</syntaxhighlight>

This function is used to detect the existence of flag parameters. For this reason, it is often accompanied by the <code>[[#sequential|sequential]]</code> modifier (or, equivalently, by <code>...&#124;[[#excluding_non-numeric_names|excluding_non-numeric_names]]&#124;[[#clearing|clearing]]&#124;...</code>).

A typical use case of this function is that of constructing [[:w:en:URL|URL]]s. For example, the following template named <syntaxhighlight lang="wikitext" inline>{{example template}}</syntaxhighlight> checks for the <code>html</code>, <code>xml</code>, <code>comments</code> and <code>removenowiki</code> flags in order to append respectively the following strings to the final URL: <code>&amp;wpGenerateRawHtml=1</code>, <code>&amp;wpGenerateXml=1</code>, <code>&amp;wpRemoveComments=0</code>, <code>&amp;wpRemoveNowiki=1</code>.

<syntaxhighlight lang="wikitext" line>{{#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.}}
}}</syntaxhighlight>

And so, when transcluded as,

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

it will generate the following output:

: {{module:params/doc/examples/link to expanded template|comments|xml
	| input = Hello world {<nowiki />{#time:r{{!}}now}<nowiki />}
}}

A copy of the example above is available at &#123;&#123;[[Module:Params/doc/examples/link to expanded template|./doc/examples/link to expanded template]]&#125;&#125;.

If you want to allow the repetition of identical flags, you can use <code>...&#124;[[#magic_for_each_value|magic_for_each_value]]&#124;[[:w:en::mw:Help:Extension:ParserFunctions#.23switch|#switch]]&#124;...</code>. Compare

<syntaxhighlight lang="wikitext">{{#invoke:params|
	setting|i|//|
	sequential|
	magic_for_each_value|#switch
		| lemon = one
		| apple = two
		| pear = three
		| quince = four
		| grapefruit = five
}}</syntaxhighlight>

with

<syntaxhighlight lang="wikitext">{{#invoke:params|
	setting|i|//|
	sequential|
	unique_coins
		| lemon = one
		| apple = two
		| pear = three
		| quince = four
		| grapefruit = five
}}</syntaxhighlight>

If the <code>[[#setting|setting]]</code> 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 (<code>h</code>), an iteration delimiter (<code>i</code>), a last iteration delimiter (<code>l</code>), a "[[:w:en:serial comma|serial-comma]]-like" last iteration delimiter (<code>s</code>), a footer (<code>f</code>), and a fallback text (<code>n</code>) can be declared via <code>[[#setting|setting]]</code> – the string assigned to the key-value pair delimiter (<code>p</code>) will be ignored.

<div style="width: 100%; height: 1.5em;"></div>
-->
=== <code>call_for_each</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>call_for_each</code> <span style="nowrap">({{module:params/doc/link to the code|call_for_each|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| [[#all_sorted|Sortable]]: Yes
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#call_for_each_value|call_for_each_value]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#invoke_for_each|invoke_for_each]]</code>, <code>[[#magic_for_each|magic_for_each]]</code>, <code>[[#call_for_each_group|call_for_each_group]]</code>, <code>{{ml|for loop}}</code>, {{tl2|for loop}}
}}

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

Some functions are like shortcuts. The <code>X_for_each|F</code> functions are similar to <code>mapping_by_X(ing)|F|(names_and_values|)list_values</code>. The latter syntax (i.e. the modifier version) allows a <code>values_and_names</code> 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 (<code>h</code>), an iteration delimiter (<code>i</code>), a last iteration delimiter (<code>l</code>), a "[[:w:en:serial comma|serial-comma]]-like" last iteration delimiter (<code>s</code>), a footer (<code>f</code>), and a fallback text (<code>n</code>) can be declared via the <code>[[#setting|setting]]</code> modifier – the string assigned to the key-value pair delimiter (<code>p</code>) will be ignored.

Calling a template for each key-value pair with

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|call_for_each|foobar}}</syntaxhighlight>

will be different from writing

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|for_each|{{foobar|$#|$@}}}}</syntaxhighlight>

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

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this function except the ''template name'' will not be trimmed of their leading and trailing spaces. The <code>call_for_each</code> ''function name'' itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>invoke_for_each</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>invoke_for_each</code> <span style="nowrap">({{module:params/doc/link to the code|invoke_for_each|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| [[#all_sorted|Sortable]]: Yes
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#invoke_for_each_value|invoke_for_each_value]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#call_for_each|call_for_each]]</code>, <code>[[#magic_for_each|magic_for_each]]</code>
}}

; Brief
: ''For each parameter passed to the current template, invoke a custom module function with at least two arguments (key and value)''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#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]|[...]}}</syntaxhighlight>

Exactly like <code>[[#call_for_each|call_for_each]]</code>, but invokes a module instead of calling a template.

Invoking a module function for each key-value pair with

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|invoke_for_each|foobar|main}}</syntaxhighlight>

will be different from writing

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|for_each|{{#invoke:foobar|main|$#|$@}}}}</syntaxhighlight>

In the first example each key-value pair will be passed to the <syntaxhighlight lang="wikitext" inline>{{#invoke:foobar|main}}</syntaxhighlight> module function, while in the second example the <code>$#</code> and <code>$@</code> 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.

<div style="width: 100%; height: 1em;"></div>

{{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 <code>invoke_for_each</code> ''function name'' itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>magic_for_each</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>magic_for_each</code> <span style="nowrap">({{module:params/doc/link to the code|magic_for_each|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| [[#all_sorted|Sortable]]: Yes
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#magic_for_each_value|magic_for_each_value]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#call_for_each|call_for_each]]</code>, <code>[[#invoke_for_each|invoke_for_each]]</code>
}}

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

Exactly like <code>[[#call_for_each|call_for_each]]</code>, but calls a [[:w:en::mw:Help:Magic words#Parser functions|parser function]] instead of a template.

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this function except the magic word will not be trimmed of their leading and trailing spaces. The <code>magic_for_each</code> ''function name'' itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>call_for_each_value</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>call_for_each_value</code> <span style="nowrap">({{module:params/doc/link to the code|call_for_each_value|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| [[#all_sorted|Sortable]]: Yes
	| Often preceeded by: <code>[[#sequential|sequential]]</code>
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#call_for_each|call_for_each]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#invoke_for_each_value|invoke_for_each_value]]</code>, <code>[[#magic_for_each_value|magic_for_each_value]]</code>, <code>[[#call_for_each_group|call_for_each_group]]</code>, <code>{{ml|for loop}}</code>, {{tl2|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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|call_for_each_value|template name|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}</syntaxhighlight>

The <code>[[#sequential|sequential]]</code> 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 (<code>h</code>), an iteration delimiter (<code>i</code>), a last iteration delimiter (<code>l</code>), a "[[:w:en:serial comma|serial-comma]]-like" last iteration delimiter (<code>s</code>), a footer (<code>f</code>), and a fallback text (<code>n</code>) can be declared via the <code>[[#setting|setting]]</code> modifier – the string assigned to the key-value pair delimiter (<code>p</code>) will be ignored.

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

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|setting|i|, |call_for_each_value|tl}}</syntaxhighlight>

This will be different from writing

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|setting|i|, |for_each|{{tl|$@}}}}</syntaxhighlight>

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

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this function except the ''template name'' will not be trimmed of their leading and trailing spaces. The <code>call_for_each_value</code> ''function name'' itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>invoke_for_each_value</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>invoke_for_each_value</code> <span style="nowrap">({{module:params/doc/link to the code|invoke_for_each_value|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| [[#all_sorted|Sortable]]: Yes
	| Often preceeded by: <code>[[#sequential|sequential]]</code>
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#call_for_each_value|call_for_each_value]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#invoke_for_each|invoke_for_each]]</code>, <code>[[#magic_for_each_value|magic_for_each_value]]</code>
}}

; 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
: <syntaxhighlight lang="wikitext" inline>{{#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]|[...]}}</syntaxhighlight>

Exactly like <code>[[#call_for_each_value|call_for_each_value]]</code>, but invokes a module instead of calling a template.

Invoking a module function for each value with

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|invoke_for_each_value|foobar|main}}</syntaxhighlight>

will be different from writing

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|for_each|{{#invoke:foobar|main|$@}}}}</syntaxhighlight>

In the first example each value will be passed to the <syntaxhighlight lang="wikitext" inline>{{#invoke:foobar|main}}</syntaxhighlight> module function, while in the second example the <code>$@</code> 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.

<div style="width: 100%; height: 1em;"></div>

{{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 <code>invoke_for_each_value</code> ''function name'' itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>magic_for_each_value</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>magic_for_each_value</code> <span style="nowrap">({{module:params/doc/link to the code|magic_for_each_value|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| [[#all_sorted|Sortable]]: Yes
	| Often preceeded by: <code>[[#sequential|sequential]]</code>
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#call_for_each_value|call_for_each_value]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#invoke_for_each_value|invoke_for_each_value]]</code>, <code>[[#magic_for_each|magic_for_each]]</code>
}}

; 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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|magic_for_each_value|parser function|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}</syntaxhighlight>

Exactly like <code>[[#call_for_each_value|call_for_each_value]]</code>, but calls a [[:w:en::mw:Help:Magic words#Parser functions|parser function]] instead of a template.

For example, if a template had the following code,

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|setting|ih|&preloadparams%5b%5d{{=}}|magic_for_each_value|urlencode|QUERY}}</syntaxhighlight>

and were transcluded as <syntaxhighlight lang="wikitext" inline>{{example template|hello world|àèìòù|foobar}}</syntaxhighlight>, the <code><nowiki>{{</nowiki>[[:w:en::mw:Help:Magic words#URL data|urlencode]]:...|QUERY<nowiki>}}</nowiki></code> parser function would be called for each incoming parameter as first argument and with <code>QUERY</code> as second argument, and finally the returned text would be prefixed with <code>&preloadparams%5b%5d=</code>. This would generate,

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

which can be used to allow the creation of pages [[:w:en::mw:Manual:Creating pages with preloaded text#Using parameters|with preloaded text and parameters]].

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this function except the magic word will not be trimmed of their leading and trailing spaces. The <code>magic_for_each_value</code> ''function name'' itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>call_for_each_group</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>call_for_each_group</code> <span style="nowrap">({{module:params/doc/link to the code|call_for_each_group|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Often preceeded by: <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code>
	| [[#all_sorted|Sortable]]: Yes
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#grouping_by_calling|grouping_by_calling]]</code>, <code>[[#call_for_each|call_for_each]]</code>, <code>[[#call_for_each_value|call_for_each_value]]</code>, <code>{{ml|for loop}}</code>, {{tl2|for loop}}
}}

; Brief
: ''Call a custom template for each group of parameters that have the same numeric suffix''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|call_for_each_group|template name|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]
}}</syntaxhighlight>

In short, this function helps you manage cases like the following, in which a template needs to be transcluded with a variable number of parameters grouped by their identical numerical suffix:

<syntaxhighlight lang="wikitext">{{My template
	| foo 1 = lorem
	| bar 1 = ipsum
	| hello 1 = dolor

	| foo 2 = sit
	| bar 2 = amet
	| hello 2 = dolor

	| foo 3 = consectetur
	| bar 3 = adipiscing
	| hello 3 = elit

	| ...
}}</syntaxhighlight>

The way it manages this situation is by repeatedly calling a custom template for each group of similar parameters. These will be stripped of their numeric id (i.e. the numeric suffix), which will be passed separetely as '''parameter zero''' (i.e. {{param|0}}) to the custom template. With the group of parameters that do not have a numeric suffix the id will be an empty string.

If you are a module writer, you might recognize some distant similarities between this function and <code>[[:w:en:Module:TableTools#affixNums|TableTools.affixNums]]</code>.

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 were an empty string (these can be captured using <code>&#123;&#123;&#123;&#125;&#125;&#125;</code> or <code>&#123;&#123;&#123;&#124;''fallback text''&#125;&#125;&#125;</code> in the callback template). Spaces between the prefix and the numeric suffix will be ignored (therefore writing {{para|foobar123}} will be identical to writing {{para|foobar&nbsp;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. {{para|1 1}}, {{para|2 1}}, etc.), if this is <code>0</code> or a negative number it will be decreased by one unit in order to leave the parameter zero undisturbed (so <code>0</code> will become <code>-1</code>, <code>-1</code> will become <code>-2</code>, and so on – if needed, you can use <code>...|[[#purging|purging]]|0|1|...</code> in the callback template to renormalize these numbers).

All unnamed arguments that follow the ''template name'' argument will appear as sequential parameters shared across all calls. 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 <code>1</code> will be decreased by one unit (i.e. <code>...|call_for_each_group&#124;example template&#124;0=Hello world&#124;...</code> will become {{para|-1|Hello world}} in the callback template – see above).

A header (<code>h</code>), an iteration delimiter (<code>i</code>), a last iteration delimiter (<code>l</code>), a "[[:w:en:serial comma|serial-comma]]-like" last iteration delimiter (<code>s</code>), a footer (<code>f</code>), and a fallback text (<code>n</code>) can be declared via the <code>[[#setting|setting]]</code> modifier – the string assigned to the key-value pair delimiter (<code>p</code>) will be ignored.

For example, if a template named <syntaxhighlight lang="wikitext" inline>{{foobar}}</syntaxhighlight> contained the following code,

<syntaxhighlight lang="wikitext">{{#invoke:params|reassorted|call_for_each_group|example template|hello|world|foo=bar}}</syntaxhighlight>

writing

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

will be equivalent to writing

<syntaxhighlight lang="wikitext">{{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
}}</syntaxhighlight>

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

<div style="width: 100%; height: 1em;"></div>

{{Anchor|Multilevel substitution warning}}{{Note|type=warn}} In writing templates, there is often the habit of signaling [[:w:en::mw:Help:Substitution#Multilevel substitution|multilevel substitutions]] using the <syntaxhighlight lang="wikitext" inline>{{{|safesubst:}}}</syntaxhighlight> notation. This is a dangerous practice, because <syntaxhighlight lang="wikitext" inline>{{{|safesubst:}}}</syntaxhighlight> means "write the parameter with an empty name, otherwise write <code>safesubst:</code>". Due to the fact that <code>call_for_each_group</code> '''can pass parameters with an empty name''', a callback template should never use <syntaxhighlight lang="wikitext" inline>{{{|safesubst:}}}</syntaxhighlight> to notate multilevel substitutions, but should use instead <syntaxhighlight lang="wikitext" inline>safesubst:<noinclude /></syntaxhighlight>. Not following this advice can lead to bugs that are hard to debug.

<div style="width: 100%; height: 1em;"></div>

At &#123;&#123;[[Module:Params/doc/examples/list of authors|./doc/examples/list of authors]]&#125;&#125; you can find an example of how to use this function to list authors the same way {{tl|Cite book}} does. For instance, writing

<syntaxhighlight lang="wikitext">{{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.
}}</syntaxhighlight>

will generate

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

See also &#123;&#123;[[Module:Params/doc/examples/tablebox|./doc/examples/tablebox]]&#125;&#125; for an example of how to exploit this function to create [[:w:en:Template:Infobox|infoboxes]], and &#123;&#123;[[Module:Params/doc/examples/four cells per row table|./doc/examples/four cells per row table]]&#125;&#125; for an example of how to exploit this function to create n-column tables.

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this function except the ''template name'' will not be trimmed of their leading and trailing spaces. The <code>call_for_each_group</code> ''function name'' itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>for_each</code> ===
{{module:params/doc/examples/informal tablebox|caption=Function <code>for_each</code> <span style="nowrap">({{module:params/doc/link to the code|for_each|code}})</span>
	| Num. of arguments: 1
	| [[#all_sorted|Sortable]]: Yes
	| Relevant [[#setting|function-only variables]]: <code>h</code>, <code>i</code>, <code>l</code>, <code>s</code>, <code>f</code>, <code>n</code>
	| ; See also
	| : <code>[[#list|list]]</code>, <code>[[#list_values|list_values]]</code>, <code>[[#list_maybe_with_names|list_maybe_with_names]]</code>, <code>{{ml|for nowiki}}</code>, {{tl2|for nowiki}}, {{tl2|expand wikitext}}
}}

; Brief
: ''For each parameter passed to the current template, expand all occurrences of <code>$#</code> and <code>$@</code> within a given text as key and value respectively''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|for_each|wikitext}}</syntaxhighlight>

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|for_each|Arg name: $#, Arg value: $@}}</syntaxhighlight>

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

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

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

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

<syntaxhighlight lang="wikitext">{{#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}}</syntaxhighlight>

<div style="width: 100%; height: 1em;"></div>

{{Note}} The argument passed to this function will not be trimmed of its leading and trailing spaces. The <code>for_each</code> ''function name'' itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1em;"></div>

== 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''. As modifiers, they expect to be piped instead of returning to the caller. Each of them can be piped to either another flag modifier or a [[#Modifiers (piping functions)|modifier]] or a [[#Functions|non-piping function]]. Unlike modifiers, the order in which flag modifiers appear has no consequences. The actions that flags do affects only functions, without affecting modifiers.

<div style="width: 100%; height: 1em;"></div>

=== <code>sequential</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>sequential</code> <span style="nowrap">({{module:params/doc/link to the code|sequential|code}})</span>
	| Num. of arguments: 0
	| Repeatable: No
	| Conflicts with: <code>[[#non-sequential|non-sequential]]</code>, <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code>
	| ; See also
	| : <code>[[#non-sequential|non-sequential]]</code>, <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>
}}

; Brief
: (IN FUNCTIONS ONLY, DOES NOT AFFECT MODIFIERS) Reduce the parameter list to the subgroup of consecutive parameters that follow {{para|1}}
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|sequential|pipe function name}}</syntaxhighlight>

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|count}}</syntaxhighlight>

This modifier does not take arguments besides the name of the function that will follow. Its purpose is solely that of signaling to non-piping functions to iterate using Lua <code>ipair()</code> instead of <code>pair()</code>. Therefore it does not remove any parameter from the list (to do that, you will need to use <code>...&#124;[[#excluding_non-numeric_names|excluding_non-numeric_names]]&#124;[[#clearing|clearing]]&#124;...</code> 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 <code>sequential</code> together with <code>[[#non-sequential|non-sequential]]</code> will generate an error.

<div style="width: 100%; height: 1em;"></div>

{{Note}} Like <code>[[#non-sequential|non-sequential]]</code>, the <code>sequential</code> modifier permanently marks a query. For instance, writing <syntaxhighlight lang="wikitext" inline>{{#invoke:params|sequential|discarding|1|...}}</syntaxhighlight> 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.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>non-sequential</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>non-sequential</code> <span style="nowrap">({{module:params/doc/link to the code|non-sequential|code}})</span>
	| Num. of arguments: 0
	| Repeatable: No
	| Conflicts with: <code>[[#sequential|sequential]]</code>
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code>
}}

; Brief
: (IN FUNCTIONS ONLY, DOES NOT AFFECT MODIFIERS) Reduce the parameter list by discarding the subgroup of consecutive parameters that follow {{para|1}}
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|non-sequential|pipe function name}}</syntaxhighlight>

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|non-sequential|setting|ih/p|{{!}}|{{=}}|list}}</syntaxhighlight>

This modifier does not take arguments besides the name of the function that will follow. Once flagged with <code>non-sequential</code>, the final function will iterate through the set of parameters that is [[:w:en:complement (set theory)|complementary]] to the one picked by <code>[[#sequential|sequential]]</code>.

Using <code>non-sequential</code> together with <code>[[#sequential|sequential]]</code> will generate an error. The modifier, on the other hand, is compatible with both <code>[[#all_sorted|all_sorted]]</code> and <code>[[#reassorted|reassorted]]</code>.

<div style="width: 100%; height: 1em;"></div>

{{Note}} Like <code>[[#sequential|sequential]]</code>, the <code>non-sequential</code> modifier permanently marks a query, and no matter what transformations will follow (see <code>[[#squeezing|squeezing]]</code>) the parameters' "sequence" will not be shown.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>all_sorted</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>all_sorted</code> <span style="nowrap">({{module:params/doc/link to the code|all_sorted|code}})</span>
	| Num. of arguments: 0
	| Repeatable: No
	| Conflicts with: <code>[[#sequential|sequential]]</code>, <code>[[#reassorted|reassorted]]</code>
	| Has no effects on: <code>[[#count|count]]</code>, <code>[[#value_of|value_of]]</code>, <code>[[#concat_and_call|concat_and_call]]</code>, <code>[[#concat_and_invoke|concat_and_invoke]]</code>, <code>[[#concat_and_magic|concat_and_magic]]</code>
	| ; See also
	| : [[:w:en:Natural sort order|Natural sort order]], <code>[[#reassorted|reassorted]]</code>, <code>[[#sequential|sequential]]</code>, <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>
}}

; 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 [[:w:en:natural sort order|natural order]]''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|all_sorted|pipe function name}}</syntaxhighlight>

{{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 <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>.

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|all_sorted|setting|ih/p|{{!}}|{{=}}|list}}</syntaxhighlight>

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 <code>all_sorted</code> modifier ensures that nothing is left out of ([[:w:en:natural sort order|natural]]) order. Attention must be paid to the fact that parameters whose name is a negative number will appear first. To avoid this the <code>[[#squeezing|squeezing]]</code> modifier can be used.<ref>To be precise, the order will not be strictly alphabetical, because this would imply that a template called with the following parameters <syntaxhighlight lang="wikitext" inline>{{foobar|-4=you|9=wanna|.=me?|11=marry|-8=do}}</syntaxhighlight> would see them reordered as follows: <syntaxhighlight lang="wikitext" inline>{{foobar|-8=do|-4=you|.=me?|9=wanna|11=marry}}</syntaxhighlight> (with the dot in the middle between negative and positive numbers). To avoid this, '''numbers are always displayed first''' (i.e. <syntaxhighlight lang="wikitext" inline>{{foobar|-8=do|-4=you|9=wanna|11=marry|.=me?}}</syntaxhighlight>).</ref>

The <code>all_sorted</code> 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:

* <code>[[#count|count]]</code>
* <code>[[#value_of|value_of]]</code>
* <code>[[#concat_and_call|concat_and_call]]</code>
* <code>[[#concat_and_invoke|concat_and_invoke]]</code>
* <code>[[#concat_and_magic|concat_and_magic]]</code>

<div style="width: 100%; height: 1em;"></div>

{{Note}} The <code>all_sorted</code> modifier cannot be used with functions that propagate several parameters together in a single call, like <code>[[#concat_and_call|concat_and_call]]</code>, <code>[[#concat_and_invoke|concat_and_invoke]]</code>, and <code>[[#concat_and_magic|concat_and_magic]]</code>, 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.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>reassorted</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>reassorted</code> <span style="nowrap">({{module:params/doc/link to the code|reassorted|code}})</span>
	| Num. of arguments: 0
	| Repeatable: No
	| Conflicts with: <code>[[#sequential|sequential]]</code>, <code>[[#all_sorted|all_sorted]]</code>
	| Has no effects on: <code>[[#count|count]]</code>, <code>[[#value_of|value_of]]</code>, <code>[[#concat_and_call|concat_and_call]]</code>, <code>[[#concat_and_invoke|concat_and_invoke]]</code>, <code>[[#concat_and_magic|concat_and_magic]]</code>
	| ; See also
	| : [[:w:en:Natural sort order|Natural sort order]], <code>[[#all_sorted|all_sorted]]</code>, <code>[[#sequential|sequential]]</code>, <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>
}}

; Brief
: ''(IN FUNCTIONS ONLY, DOES NOT AFFECT MODIFIERS) When the time will come, all parameters will be dispatched sorted: first non numeric ones in [[:w:en:natural sort order|natural order]]'', then the numeric ones in ascending order
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|reassorted|pipe function name}}</syntaxhighlight>

This modifier is similar to <code>[[#all_sorted|all_sorted]]</code>, but numbers are iterated last (as in "bar, foo, hello, zebra, 1, 2, 3, …").

<div style="width: 100%; height: 1em;"></div>

{{Note}} The <code>reassorted</code> modifier cannot be used with functions that propagate several parameters together in a single call, like <code>[[#concat_and_call|concat_and_call]]</code>, <code>[[#concat_and_invoke|concat_and_invoke]]</code>, and <code>[[#concat_and_magic|concat_and_magic]]</code>, 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.

<div style="width: 100%; height: 1em;"></div>

== 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 piped to either another modifier or a [[#Flag modifiers (piping functions)|flag modifier]] or a [[#Functions|non-piping function]]. The actions that modifiers do are done sequentially, in the same order chosen during the invocation of this module.

<div style="width: 100%; height: 1em;"></div>

=== <code>setting</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>setting</code> <span style="nowrap">({{module:params/doc/link to the code|setting|code}})</span>
	| Num. of arguments: 2–8 (variable)
	| Repeatable: Yes
	| ; Memory slots
	| : {{Br separated entries
		| <code>p</code> Key-value delimiter
		| <code>i</code> Iteration delimiter
		| <code>l</code> Last iteration delimiter
		| <code>h</code> Header text
		| <code>f</code> Footer text
		| <code>n</code> Fallback text
		| <code>s</code> “[[:w:en:serial comma|serial-comma]]-like” last iteration delimiter
	}}
	| ; See also
	| : <code>[[#setting_by_flushing|setting_by_flushing]]</code>, <code>[[#combining|combining]]</code>, <code>[[#combining_values|combining_values]]</code>
}}

; Brief
: ''Define glue strings''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|setting|directives|...|pipe function name}}</syntaxhighlight>

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:

* <syntaxhighlight lang="wikitext" inline>{{#invoke:params|setting|i|{{!}}|list_values}}</syntaxhighlight>
*: ↳ Set the value of ''iteration delimiter'' to <code>|</code>, then list all values
* <syntaxhighlight lang="wikitext" inline>{{#invoke:params|setting|ih|{{!}}|list_values}}</syntaxhighlight>
*: ↳ Set the value of both ''header text'' and ''iteration delimiter'' to <code>|</code>, then list all values
* <syntaxhighlight lang="wikitext" inline>{{#invoke:params|setting|ih/p|{{!}}|{{=}}|list}}</syntaxhighlight>
*: ↳ Set the value of both ''header text'' and ''iteration delimiter'' to <code>|</code>, set ''key-value pair delimiter'' to <code>=</code>, then list all parameters
* <syntaxhighlight lang="wikitext" inline>{{#invoke:params|setting|ih/p/n|{{!}}|{{=}}|No parameters were passed|list}}</syntaxhighlight>
*: ↳ Set the value of both ''header text'' and ''iteration delimiter'' to <code>|</code>, set ''key-value pair delimiter'' to <code>=</code>, set ''fallback text'' to <code>No parameters were passed</code>, 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:

{| class="wikitable" style="margin-left: auto; margin-right: auto;"
|-
! Slots
! Variable
! Description
|-
| <code>p</code>
| ''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.
|-
| <code>i</code>
| ''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 <code>l</code> is not given, or three or more parameters when <code>l</code> is given.
|-
| <code>l</code>
| ''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 <code>i</code>.
|-
| <code>s</code>
| ''"[[:w:en:Serial comma|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 <code>l</code>.
|-
| <code>h</code>
| ''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.
|-
| <code>f</code>
| ''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.
|-
| <code>n</code>
| ''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 <syntaxhighlight lang="wikitext" inline>{{#invoke:params|setting|ih/p|...}}</syntaxhighlight> will be equivalent to writing

<syntaxhighlight lang="wikitext">{{#invoke:params|setting| i
	h	/ p |...}}</syntaxhighlight>

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

The <code>s</code> slot has been created with the [[:w:en:Serial comma|Oxford comma]] in mind. For instance, the following imaginary <syntaxhighlight lang="wikitext" inline>{{Foobar see also}}</syntaxhighlight> template adds a comma before the "and" conjunction when more than two page names are provided:

<syntaxhighlight lang="wikitext">{{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}}
}}}}</syntaxhighlight>

You can find this example at &#123;&#123;[[Module:Params/doc/examples/Oxford comma|./doc/examples/Oxford comma]]&#125;&#125;. Thus, <syntaxhighlight lang="wikitext" inline>{{module:params/doc/examples/Oxford comma|Latin|English|German|Italian}}</syntaxhighlight> will generate

{{module:params/doc/examples/Oxford comma|Latin|English|German|Italian}}

<div style="width: 100%; height: 1em;"></div>

{{Note}} The <code>setting</code> 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).

<div style="width: 100%; height: 1.5em;"></div>

=== <code>scoring</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>scoring</code> <span style="nowrap">({{module:params/doc/link to the code|scoring|code}})</span>
	| Num. of arguments: 1–2
	| Repeatable: Yes
	| ; See also
	| : <code>[[#count|count]]</code>, <code>[[#snapshotting|snapshotting]]</code>
}}

; Brief
: ''Count the number of parameters wherewith a template was called and save the result into a new parameter''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|scoring|new parameter name|[context]|pipe function name}}</syntaxhighlight>

This is the modifier version of the <code>[[#count|count]]</code> function: instead of outputting the number of current parameters, the result will be saved into a new parameter (which will not be counted in the result).

The ''context'' optional flag specifies in which stack the new parameter must be saved. Possible values are <code>in_substack</code> (for saving it in a new substack—see <code>[[#snapshotting|snapshotting]]</code> for more information on the stacking mechanism), and <code>here</code> (for saving it in the current stack). When omitted it defaults to <code>here</code>.

Since <code>scoring</code> is a modifier, [[#Flag modifiers (piping functions)|flag modifiers]] like <code>[[#sequential|sequential]]</code> and <code>[[#non-sequential|non-sequential]]</code> won't affect the result.

Example #2: Count the current parameters and save the result in the current stack:

<syntaxhighlight lang="wikitext">{{#invoke:params|
	scoring|total|
	setting|i/p|<br />| → |
	list
}}</syntaxhighlight>

Example #1: Count the current parameters and save the result in a new substack:

<syntaxhighlight lang="wikitext">{{#invoke:params|
	scoring|total|in_substack|
	mapping_by_mixing|☑ $@|
	flushing|
	setting|i/p|<br />| → |
	list
}}</syntaxhighlight>

<div style="width: 100%; height: 1em;"></div>

{{Note}} The <code>scoring</code> modifier name and all its arguments will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>squeezing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>squeezing</code> <span style="nowrap">({{module:params/doc/link to the code|squeezing|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#sequential|sequential]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[:w:en:Module:TableTools#compressSparseArray|TableTools.compressSparseArray]]</code>
}}

; Brief
: ''Rearrange all parameters that have numeric names to form a compact sequence starting from 1, keeping the same order''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|squeezing|pipe function name}}</syntaxhighlight>

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|squeezing|sequential|setting|i/p|<br />|: |list}}</syntaxhighlight>

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 <code>[[:w:en:Module:TableTools#compressSparseArray|TableTools.compressSparseArray]]</code>.

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

# <syntaxhighlight lang="wikitext" inline>{{...|excluding_numeric_names|...}}</syntaxhighlight>
# <syntaxhighlight lang="wikitext" inline>{{...|with_name_not_matching|^%-?%d+$|...}}</syntaxhighlight>
# <syntaxhighlight lang="wikitext" inline>{{...|non-sequential|squeezing|...}}</syntaxhighlight>
# <syntaxhighlight lang="wikitext" inline>{{...|squeezing|non-sequential|...}}</syntaxhighlight>

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>filling_the_gaps</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>filling_the_gaps</code> <span style="nowrap">({{module:params/doc/link to the code|filling_the_gaps|code}})</span>
	| Num. of arguments: 1
	| Repeatable: Yes
	| ; See also
	| : <code>[[#squeezing|squeezing]]</code>, <code>[[#sequential|sequential]]</code>, <code>[[#clearing|clearing]]</code>
}}

; Brief
: ''Assign a custom string to all undefined numeric parameters between 1 or a lower numeric parameter name provided and the maximum numeric parameter provided''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|filling_the_gaps|new value|pipe function name}}</syntaxhighlight>

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|filling_the_gaps|hello!|sequential|setting|i/p|<br />|: |list}}</syntaxhighlight>

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 (<code>...&#124;filling_the_gaps&#124;foo&#124;...</code>).

{| class="wikitable" style="margin-left: auto; margin-right: auto;"
|+ Numeric parameters provided
|-
! Before calling <code>filling_the_gaps</code>
! After calling <code>filling_the_gaps</code>
|-
| <code>&#124;1&#61;...</code>
| <code>&#124;1&#61;...</code>
|-
| <code>&#124;2&#61;...</code>
| <code>&#124;1&#61;foo</code>, <code>&#124;2&#61;...</code>
|-
| <code>&#124;6&#61;...</code>, <code>&#124;9&#61;...</code>
| <code>&#124;1&#61;foo</code>, <code>&#124;2&#61;foo</code>, <code>&#124;3&#61;foo</code>, <code>&#124;4&#61;foo</code>, <code>&#124;5&#61;foo</code>, <code>&#124;6&#61;...</code>, <code>&#124;7&#61;foo</code>, <code>&#124;8&#61;foo</code>, <code>&#124;9&#61;...</code>
|-
| <code>&#124;-5&#61;...</code>, <code>&#124;-3&#61;...</code>
| <code>&#124;-5&#61;...</code>, <code>&#124;-4&#61;foo</code>, <code>&#124;-3&#61;...</code>
|-
| <code>&#124;-5&#61;...</code>, <code>&#124;-3&#61;...</code>, <code>&#124;1&#61;...</code>
| <code>&#124;-5&#61;...</code>, <code>&#124;-4&#61;foo</code>, <code>&#124;-3&#61;...</code>, <code>&#124;-2&#61;foo</code>, <code>&#124;-1&#61;foo</code>, <code>&#124;0&#61;foo</code>, <code>&#124;1&#61;...</code>
|-
| <code>&#124;-1&#61;...</code>
| <code>&#124;-1&#61;...</code>
|-
| <code>&#124;-2&#61;...</code>
| <code>&#124;-2&#61;...</code>
|}

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>clearing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>clearing</code> <span style="nowrap">({{module:params/doc/link to the code|clearing|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| Often accompanied by: <code>[[#sequential|sequential]]</code>
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#excluding_non-numeric_names|excluding_non-numeric_names]]</code>
}}

; Brief
: ''Remove all numeric parameters that are not in the sequence''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|clearing|pipe function name}}</syntaxhighlight>

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

Unlike <code>[[#sequential|sequential]]</code> – which affects only the way parameters are shown – this modifier actually removes all non-sequential numeric parameters, albeit leaves non-numeric parameters intact.

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|clearing|setting|i/p|<br />|: |list}}</syntaxhighlight>

If you want to remove also non-numeric parameters, add the <code>[[#excluding_non-numeric_names|excluding_non-numeric_names]]</code> modifier:

<syntaxhighlight lang="wikitext">{{#invoke:params|clearing|excluding_non-numeric_names|setting|i/p|<br />|: |list}}</syntaxhighlight>

If you want instead to remove sequential parameters and leave the rest, you have two possibilities. You can either use <code>&#123;&#123;...&#124;[[#cutting|cutting]]&#124;-1&#124;1&#124;...&#125;&#125;</code> when you want to shift the remaining numeric parameters accordingly:

<syntaxhighlight lang="wikitext">{{#invoke:params|cutting|-1|1|setting|i/p|<br />|: |list}}</syntaxhighlight>

Or you can use <code>&#123;&#123;...&#124;[[#entering_substack|entering_substack]]&#124;[[#clearing|clearing]]&#124;[[#detaching_substack|detaching_substack]]&#124;[[#dropping_substack|dropping_substack]]&#124;...&#125;&#125;</code> if you want the remaining non-sequential parameters to keep occupying the same position as before:

<syntaxhighlight lang="wikitext">{{#invoke:params|entering_substack|clearing|detaching_substack|dropping_substack|setting|i/p|<br />|: |list}}</syntaxhighlight>

<div style="width: 100%; height: 1.5em;"></div>

=== <code>cutting</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>cutting</code> <span style="nowrap">({{module:params/doc/link to the code|cutting|code}})</span>
	| Num. of arguments: 2
	| Repeatable: Yes
	| Often accompanied by: <code>[[#sequential|sequential]]</code>
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[#cropping|cropping]]</code>, <code>[[#purging|purging]]</code>, <code>[[#backpurging|backpurging]]</code>, <code>[[#shifting|shifting]]</code>, <code>[[#reversing_numeric_names|reversing_numeric_names]]</code><!--, <code>[[#mirroring_numeric_names|mirroring_numeric_names]]</code>, <code>[[#pivoting_numeric_names|pivoting_numeric_names]]</code>, <code>[[#swapping_numeric_names|swapping_numeric_names]]</code>-->, <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>, <code>[[#splicing|splicing]]</code>
}}

; Brief
: ''Remove zero or more parameters from the beginning and the end '''of the parameters' sequence''', shifting everything else accordingly''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|cutting|left trim|right trim|pipe function name}}</syntaxhighlight>

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. <syntaxhighlight lang="wikitext" inline>{{#invoke:params|cutting|-3|0|list}}</syntaxhighlight> indicates that the last three arguments must not be discarded.

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|cutting|0|2|sequential|call_for_each_value|example template}}</syntaxhighlight>

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 <code>cutting</code> modifier. For instance, the following code prints the last unnamed parameter passed, but only if at least two parameters were passed:

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|cutting|1|0|cutting|-1|0|list_values}}</syntaxhighlight>

{{Note|text='''Suggestion:''' Although <syntaxhighlight lang="wikitext" inline>{{#invoke:params|cutting|-1|1|...}}</syntaxhighlight> de facto gets rid of all sequential parameters, in most cases it is clearer and more idiomatic to write <syntaxhighlight lang="wikitext" inline>{{#invoke:params|non-sequential|...}}</syntaxhighlight> 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 <code>[[#non-sequential|non-sequential]]</code> does not take effect until the final function is invoked. Writing instead <syntaxhighlight lang="wikitext" inline>{{#invoke:params|sequential|cutting|-1|1|...}}</syntaxhighlight> will leave zero arguments to show.}} 

<div style="width: 100%; height: 1.5em;"></div>

=== <code>cropping</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>cropping</code> <span style="nowrap">({{module:params/doc/link to the code|cropping|code}})</span>
	| Num. of arguments: 2
	| Repeatable: Yes
	| Often accompanied by: <code>[[#sequential|sequential]]</code>
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[#cutting|cutting]]</code>, <code>[[#purging|purging]]</code>, <code>[[#backpurging|backpurging]]</code>, <code>[[#shifting|shifting]]</code>, <code>[[#reversing_numeric_names|reversing_numeric_names]]</code><!--, <code>[[#mirroring_numeric_names|mirroring_numeric_names]]</code>, <code>[[#pivoting_numeric_names|pivoting_numeric_names]]</code>, <code>[[#swapping_numeric_names|swapping_numeric_names]]</code>-->, <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>, <code>[[#splicing|splicing]]</code>
}}

; Brief
: ''Remove zero or more parameters from the beginning and the end of the '''list of numeric parameters''' (not only the sequential ones)''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|cropping|left crop|right crop|pipe function name}}</syntaxhighlight>

This modifier is very similar to <code>[[#cutting|cutting]]</code>, 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. {{para|-1000|...}} and {{para|1000|...}} in the case of <syntaxhighlight lang="wikitext" inline>{{foobar|-1000=hello|1=my|1000=darling}}</syntaxhighlight>). If any of the two arguments contains a negative number its absolute value indicates what must be left ''on the opposite side''.

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|cropping|2|1|sequential|call_for_each_value|example template}}</syntaxhighlight>

For instance, when a template transcluded as <syntaxhighlight lang="wikitext" inline>{{example template|-2=minus two|0=zero|1=one|2=two|3=three|19=nineteen|20=twenty}}</syntaxhighlight> uses the <code>[[#cutting|cutting]]</code> modifier with <code>2</code> and <code>1</code> as arguments, the following parameters are left:

: -2: minus two
: 0: zero
: 16: nineteen
: 17: twenty

If instead the template were to use the <code>cropping</code> modifier with <code>2</code> and <code>1</code> 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.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>purging</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>purging</code> <span style="nowrap">({{module:params/doc/link to the code|purging|code}})</span>
	| Num. of arguments: 2
	| Repeatable: Yes
	| Often accompanied by: <code>[[#sequential|sequential]]</code>
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[#cutting|cutting]]</code>, <code>[[#cropping|cropping]]</code>, <code>[[#backpurging|backpurging]]</code>, <code>[[#shifting|shifting]]</code>, <code>[[#reversing_numeric_names|reversing_numeric_names]]</code><!--, <code>[[#mirroring_numeric_names|mirroring_numeric_names]]</code>, <code>[[#pivoting_numeric_names|pivoting_numeric_names]]</code>, <code>[[#swapping_numeric_names|swapping_numeric_names]]</code>-->, <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>, <code>[[#splicing|splicing]]</code>
}}

; Brief
: ''Remove zero or more parameters from any point of the list of numeric parameters, shifting everything accordingly''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|purging|start offset|length|pipe function name}}</syntaxhighlight>

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. <syntaxhighlight lang="wikitext" inline>{{#invoke:params|purging|5|0|list}}</syntaxhighlight> indicates that every numeric argument whose numeric name is greater than <code>4</code> must be removed.

Example #1 (purge the first parameter):

<syntaxhighlight lang="wikitext">{{#invoke:params|purging|1|1|call_for_each_value|example template}}</syntaxhighlight>

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

<syntaxhighlight lang="wikitext">{{#invoke:params|purging|2|3|call_for_each_value|example template}}</syntaxhighlight>

<div style="width: 100%; height: 1.5em;"></div>

=== <code>backpurging</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>backpurging</code> <span style="nowrap">({{module:params/doc/link to the code|backpurging|code}})</span>
	| Num. of arguments: 2
	| Repeatable: Yes
	| Often accompanied by: <code>[[#sequential|sequential]]</code>
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[#cutting|cutting]]</code>, <code>[[#cropping|cropping]]</code>, <code>[[#purging|purging]]</code>, <code>[[#reversing_numeric_names|reversing_numeric_names]]</code><!--, <code>[[#mirroring_numeric_names|mirroring_numeric_names]]</code>, <code>[[#pivoting_numeric_names|pivoting_numeric_names]]</code>, <code>[[#swapping_numeric_names|swapping_numeric_names]]</code>-->, <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>, <code>[[#splicing|splicing]]</code>
}}

; Brief
: ''Remove zero or more parameters from any point of the list of numeric parameters, moving backwards and shifting everything accordingly''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|backpurging|start offset|length|pipe function name}}</syntaxhighlight>

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. <syntaxhighlight lang="wikitext" inline>{{#invoke:params|backpurging|5|0|list}}</syntaxhighlight> indicates that every numeric argument whose numeric name is less than <code>6</code> must be removed.

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|backpurging|3|1|call_for_each_value|example template}}</syntaxhighlight>

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

<syntaxhighlight lang="wikitext">{{#invoke:params|backpurging|0|0|for_each|[$#: $@]}}</syntaxhighlight>

<div style="width: 100%; height: 1.5em;"></div>

=== <code>shifting</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>shifting</code> <span style="nowrap">({{module:params/doc/link to the code|shifting|code}})</span>
	| Num. of arguments: 1
	| Repeatable: Yes
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[#cutting|cutting]]</code>, <code>[[#cropping|cropping]]</code>, <code>[[#purging|purging]]</code>, <code>[[#backpurging|backpurging]]</code>, <code>[[#reversing_numeric_names|reversing_numeric_names]]</code><!--, <code>[[#mirroring_numeric_names|mirroring_numeric_names]]</code>, <code>[[#pivoting_numeric_names|pivoting_numeric_names]]</code>, <code>[[#swapping_numeric_names|swapping_numeric_names]]</code>-->, <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>, <code>[[#splicing|splicing]]</code>
}}

; Brief
: ''Add a positive or a negative number to all numeric parameter names''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|shifting|addend|pipe function name}}</syntaxhighlight>

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|shifting|-2|for_each|[$#: $@]}}</syntaxhighlight>

<div style="width: 100%; height: 1em;"></div>

{{Note}} The <code>shifting</code> modifier name will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>reversing_numeric_names</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>reversing_numeric_names</code> <span style="nowrap">({{module:params/doc/link to the code|reversing_numeric_names|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| Often accompanied by: <code>[[#sequential|sequential]]</code>
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[#cutting|cutting]]</code>, <code>[[#cropping|cropping]]</code>, <code>[[#purging|purging]]</code>, <code>[[#backpurging|backpurging]]</code>, <code>[[#shifting|shifting]]</code><!--, <code>[[#mirroring_numeric_names|mirroring_numeric_names]]</code>, <code>[[#pivoting_numeric_names|pivoting_numeric_names]]</code>, <code>[[#swapping_numeric_names|swapping_numeric_names]]</code>-->, <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>, <code>[[#splicing|splicing]]</code>
}}

; Brief
: ''Reverse the order of all numeric parameters (not only sequential ones), making sure that the largest numeric parameter and {{para|1}} are swapped''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|reversing_numeric_names|pipe function name}}</syntaxhighlight>

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

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|reversing_numeric_names|for_each|[$#: $@]}}</syntaxhighlight>

An example that uses this function is available at &#123;&#123;[[Module:Params/doc/examples/watchlist|./doc/examples/watchlist]]&#125;&#125;.

{{Note}} If negative parameters are present this function becomes non-invertible. This means that <syntaxhighlight lang="wikitext" inline>{{#invoke:params|reversing_numeric_names|reversing_numeric_names|...}}</syntaxhighlight> 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 {{para|1}}.
<!--
<div style="width: 100%; height: 1.5em;"></div>

=== <code>mirroring_numeric_names</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>mirroring_numeric_names</code> <span style="nowrap">({{module:params/doc/link to the code|mirroring_numeric_names|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| Often accompanied by: <code>[[#sequential|sequential]]</code>
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[#cutting|cutting]]</code>, <code>[[#cropping|cropping]]</code>, <code>[[#purging|purging]]</code>, <code>[[#backpurging|backpurging]]</code>, <code>[[#shifting|shifting]]</code>, <code>[[#reversing_numeric_names|reversing_numeric_names]]</code>, <code>[[#pivoting_numeric_names|pivoting_numeric_names]]</code>, <code>[[#swapping_numeric_names|swapping_numeric_names]]</code>, <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>, <code>[[#splicing|splicing]]</code>
}}

; Brief
: ''Reverse the order of all numeric parameters (not only sequential ones)''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|mirroring_numeric_names|pipe function name}}</syntaxhighlight>

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

This modifier reverses the order of numeric parameters, making sure that the minimum and the maximum numeric parameters remain always the same (albeit inverted).

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|mirroring_numeric_names|for_each|[$#: $@]}}</syntaxhighlight>

<div style="width: 100%; height: 1.5em;"></div>

=== <code>pivoting_numeric_names</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>pivoting_numeric_names</code> <span style="nowrap">({{module:params/doc/link to the code|pivoting_numeric_names|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| Often accompanied by: <code>[[#sequential|sequential]]</code>
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[#cutting|cutting]]</code>, <code>[[#cropping|cropping]]</code>, <code>[[#purging|purging]]</code>, <code>[[#backpurging|backpurging]]</code>, <code>[[#shifting|shifting]]</code>, <code>[[#reversing_numeric_names|reversing_numeric_names]]</code>, <code>[[#mirroring_numeric_names|mirroring_numeric_names]]</code>, <code>[[#swapping_numeric_names|swapping_numeric_names]]</code>, <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>, <code>[[#splicing|splicing]]</code>
}}

; Brief
: ''Reverse the order of all numeric parameters (not only sequential ones), '''keeping the parameters' sequence always centered'''''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|pivoting_numeric_names|pipe function name}}</syntaxhighlight>

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

This modifier reverses the order of numeric parameters, making sure that those in the parameters' sequence always remain in the sequence. As a consequence, the values of the minimum and the maximum numeric parameters may change. If no sequence is present this modifier is identical to <code>[[#mirroring_numeric_names|mirroring_numeric_names]]</code>.

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|pivoting_numeric_names|for_each|[$#: $@]}}</syntaxhighlight>

<div style="width: 100%; height: 1.5em;"></div>

=== <code>swapping_numeric_names</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>swapping_numeric_names</code> <span style="nowrap">({{module:params/doc/link to the code|swapping_numeric_names|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| Often accompanied by: <code>[[#sequential|sequential]]</code>
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[#cutting|cutting]]</code>, <code>[[#cropping|cropping]]</code>, <code>[[#purging|purging]]</code>, <code>[[#backpurging|backpurging]]</code>, <code>[[#shifting|shifting]]</code>, <code>[[#mirroring_numeric_names|mirroring_numeric_names]]</code>, <code>[[#pivoting_numeric_names|pivoting_numeric_names]]</code>, <code>[[#sorting_sequential_values|sorting_sequential_values]]</code>, <code>[[#splicing|splicing]]</code>
}}

; Brief
: ''Swap the lowest numeric parameter with the highest, the second lowest with the second highest, and so on, keeping the sequence in the same place albeit in reverse order''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|swapping_numeric_names|pipe function name}}</syntaxhighlight>

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

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|swapping_numeric_names|for_each|[$#: $@]}}</syntaxhighlight>
-->
<div style="width: 100%; height: 1.5em;"></div>

=== <code>sorting_sequential_values</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>sorting_sequential_values</code> <span style="nowrap">({{module:params/doc/link to the code|sorting_sequential_values|code}})</span>
	| Num. of arguments: 0 or 1
	| Repeatable: Yes
	| Often accompanied by: <code>[[#sequential|sequential]]</code>
	| ; See also
	| : <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[#cutting|cutting]]</code>, <code>[[#cropping|cropping]]</code>, <code>[[#purging|purging]]</code>, <code>[[#backpurging|backpurging]]</code>, <code>[[#shifting|shifting]]</code>, <code>[[#reversing_numeric_names|reversing_numeric_names]]</code><!--, <code>[[#mirroring_numeric_names|mirroring_numeric_names]]</code>, <code>[[#pivoting_numeric_names|pivoting_numeric_names]]</code>, <code>[[#swapping_numeric_names|swapping_numeric_names]]</code>-->, <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code>
}}

; Brief
: ''Sort the order of sequential values''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|sorting_sequential_values|[criterion]|pipe function name}}</syntaxhighlight>

{{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 <code>[[#all_sorted|all_sorted]]</code>.

This modifier optionally supports one argument to specify the sorting criterion. Currently the only possible criterions are <code>alphabetically</code>, for ordering sequential values in [[:w:en:alphabetical order|alphabetical sort order]], and <code>naturally</code>, for ordering sequential values in [[:w:en:natural sort order|natural sort order]]. If this argument is omitted it defaults to <code>alphabetically</code>.

Example (alphabetical sort order):

<syntaxhighlight lang="wikitext">{{#invoke:params|sorting_sequential_values|for_each|[$#: $@]}}</syntaxhighlight>

Example (natural sort order):

<syntaxhighlight lang="wikitext">{{#invoke:params|sorting_sequential_values|naturally|for_each|[$#: $@]}}</syntaxhighlight>

<div style="width: 100%; height: 1.5em;"></div>

=== <code>splicing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>splicing</code> <span style="nowrap">({{module:params/doc/link to the code|splicing|code}})</span>
	| Num. of arguments: ''Ad libitum'' (min. 2)
	| Repeatable: Yes
	| ; See also
	| : <code>[[#imposing|imposing]]</code>, <code>[[#providing|providing]]</code>, <code>[[#reassigning|reassigning]]</code>, <code>[[#sequential|sequential]]</code>, <code>[[#squeezing|squeezing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#clearing|clearing]]</code>, <code>[[#cutting|cutting]]</code>, <code>[[#cropping|cropping]]</code>, <code>[[#purging|purging]]</code>, <code>[[#backpurging|backpurging]]</code>, <code>[[#shifting|shifting]]</code>, <code>[[#reversing_numeric_names|reversing_numeric_names]]</code>, <code>[[#mirroring_numeric_names|mirroring_numeric_names]]</code>, <code>[[#pivoting_numeric_names|pivoting_numeric_names]]</code>, <code>[[#swapping_numeric_names|swapping_numeric_names]]</code>, <code>[[#discarding|discarding]]</code>, <code>[[#all_sorted|all_sorted]]</code>, <code>[[#reassorted|reassorted]]</code>, <code>[[#new|new]]</code>
}}

; Brief
: ''Add or remove numeric parameters from any position, shifting the list of numeric parameters accordingly''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|splicing|[add to position]|position|increment|[number of elements to write]|...|pipe function name}}</syntaxhighlight>

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 <syntaxhighlight lang="wikitext" inline>{{My template|one|two|three}}</syntaxhighlight> and—independently of how many sequential parameters were passed—you want to insert <code>...&#124;hello&#124;world&#124;...</code> before the last sequential parameter (thus creating in this case <syntaxhighlight lang="wikitext" inline>{{My template|one|two|hello|world|three}}</syntaxhighlight>), <code>splicing</code> becomes the way to go (in this case <syntaxhighlight lang="wikitext" inline>...|splicing|add_last_of_sequence|0|2|2|hello|world|...</syntaxhighlight>).

The ''add to position'' optional flag argument can either be <code>add_nothing</code>, <code>add_smallest_number</code>, <code>add_last_of_sequence</code>, or <code>add_largest_number</code>. When omitted it defaults to <code>add_nothing</code>. 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 <code>0</code>. 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,

<syntaxhighlight lang="wikitext">{{My template|-3=minus three|-2=minus two|-1=minus one|0=zero|one|two|three|15=fifteen}}</syntaxhighlight>

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 <code>splicing</code>.

{| class="wikitable"
|-
! Use of <code>splicing</code>
! Computed ''position''
! Result
|- style="vertical-align: top;"
| <syntaxhighlight lang="wikitext" inline>...|splicing|4|2|2|hello|world|...</syntaxhighlight>
| <code>4</code> + ''nothing'' = 4
| {{#invoke:params|new|
	imposing|-3|minus three|
	imposing|-2|minus two|
	imposing|-1|minus one|
	imposing|0|zero|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|15|fifteen|
	splicing|4|2|2|hello|world|
	setting|i/p|; |→|
	all_sorted|
	list
}}
|- style="vertical-align: top;"
| <syntaxhighlight lang="wikitext" inline>...|splicing|add_last_of_sequence|1|2|2|hello|world|...</syntaxhighlight>
| <code>1</code> + ''last of sequence'' = 4
| {{#invoke:params|new|
	imposing|-3|minus three|
	imposing|-2|minus two|
	imposing|-1|minus one|
	imposing|0|zero|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|15|fifteen|
	splicing|add_last_of_sequence|1|2|2|hello|world|
	setting|i/p|; |→|
	all_sorted|
	list
}}
|- style="vertical-align: top;"
| <syntaxhighlight lang="wikitext" inline>...|splicing|add_smallest_number|-2|2|2|hello|world|...</syntaxhighlight>
| <code>-2</code> + ''smallest number'' = −5
| {{#invoke:params|new|
	imposing|-3|minus three|
	imposing|-2|minus two|
	imposing|-1|minus one|
	imposing|0|zero|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|15|fifteen|
	splicing|add_smallest_number|-2|2|2|hello|world|
	setting|i/p|; |→|
	all_sorted|
	list
}}
|- style="vertical-align: top;"
| <syntaxhighlight lang="wikitext" inline>...|splicing|add_largest_number|-2|100|2|hello|world|...</syntaxhighlight>
| <code>-2</code> + ''largest number'' = 13
| {{#invoke:params|new|
	imposing|-3|minus three|
	imposing|-2|minus two|
	imposing|-1|minus one|
	imposing|0|zero|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|15|fifteen|
	splicing|add_largest_number|-2|100|2|hello|world|
	setting|i/p|; |→|
	all_sorted|
	list
}}
|- style="vertical-align: top;"
| <syntaxhighlight lang="wikitext" inline>...|splicing|add_nothing|1|0|1|hello|...</syntaxhighlight>
| <code>1</code> + ''nothing'' = 1
| {{#invoke:params|new|
	imposing|-3|minus three|
	imposing|-2|minus two|
	imposing|-1|minus one|
	imposing|0|zero|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|15|fifteen|
	splicing|add_nothing|1|0|1|hello|
	setting|i/p|; |→|
	all_sorted|
	list
}}
|- style="vertical-align: top;"
| <syntaxhighlight lang="wikitext" inline>...|splicing|add_nothing|1|-1|1|hello|...</syntaxhighlight>
| <code>1</code> + ''nothing'' = 1
| {{#invoke:params|new|
	imposing|-3|minus three|
	imposing|-2|minus two|
	imposing|-1|minus one|
	imposing|0|zero|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|15|fifteen|
	splicing|add_nothing|1|-1|1|hello|
	setting|i/p|; |→|
	all_sorted|
	list
}}
|- style="vertical-align: top;"
| <syntaxhighlight lang="wikitext" inline>...|splicing|1|-1|...</syntaxhighlight> or <syntaxhighlight lang="wikitext" inline>...|splicing|1|-1|0|...</syntaxhighlight>
| <code>1</code> + ''nothing'' = 1
| {{#invoke:params|new|
	imposing|-3|minus three|
	imposing|-2|minus two|
	imposing|-1|minus one|
	imposing|0|zero|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|15|fifteen|
	splicing|1|-1|
	setting|i/p|; |→|
	all_sorted|
	list
}}
|}

<div style="width: 100%; height: 1em;"></div>

{{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 <code>splicing</code> modifier name itself, instead, will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>imposing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>imposing</code> <span style="nowrap">({{module:params/doc/link to the code|imposing|code}})</span>
	| Num. of arguments: 2
	| Repeatable: Yes
	| ; See also
	| : <code>[[#providing|providing]]</code>, <code>[[#reassigning|reassigning]]</code>, <code>[[#discarding|discarding]]</code>, <code>[[#splicing|splicing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#new|new]]</code>
}}

; Brief
: ''Impose a new value to a pre-existing parameter or create a new parameter''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|imposing|name|value|pipe function name}}</syntaxhighlight>

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|imposing|foo|bar|imposing|hello|world|for_each|[$#: $@]}}</syntaxhighlight>

<div style="width: 100%; height: 1em;"></div>

{{Note}} The value assigned will not be trimmed of its leading and trailing spaces. The name of the parameter and the <code>imposing</code> modifier name itself, instead, will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>providing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>providing</code> <span style="nowrap">({{module:params/doc/link to the code|providing|code}})</span>
	| Num. of arguments: 2
	| Repeatable: Yes
	| ; See also
	| : <code>[[#imposing|imposing]]</code>, <code>[[#reassigning|reassigning]]</code>, <code>[[#discarding|discarding]]</code>, <code>[[#splicing|splicing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#new|new]]</code>
}}

; Brief
: ''Assign a new value to a parameter, but only when missing, otherwise keep the previous value''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|providing|name|value|pipe function name}}</syntaxhighlight>

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|providing|foo|bar|providing|hello|world|for_each|[$#: $@]}}</syntaxhighlight>

<div style="width: 100%; height: 1em;"></div>

{{Note}} The value assigned will not be trimmed of its leading and trailing spaces. The name of the parameter and the <code>providing</code> modifier name itself, instead, will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>reassigning</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>reassigning</code> <span style="nowrap">({{module:params/doc/link to the code|reassigning|code}})</span>
	| Num. of arguments: 2–3
	| Repeatable: Yes
	| ; See also
	| : <code>[[#imposing|imposing]]</code>, <code>[[#providing|providing]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#renaming_by_mixing|renaming_by_mixing]]</code>, <code>[[#discarding|discarding]]</code>, <code>[[#splicing|splicing]]</code>, <code>[[#filling_the_gaps|filling_the_gaps]]</code>, <code>[[#new|new]]</code>
}}

; Brief
: ''Copy or move one parameter into another, choosing how to handle missing or existing parameters.''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|reassigning|source|destination|[mode]|pipe function name}}</syntaxhighlight>

The ''mode'' argument can be one of the following flags:

{| class="wikitable"
|-
! Flag !! Effect
|-
| ''(omitted)'' || rowspan="2" | Rename the first parameter to the second parameter regardless of whether the first parameter exists. If the first parameter is missing, the second parameter is deleted.
|-
| <code>transfer</code>
|-
| <code>clone</code> || Copy the content of the first parameter to the second parameter regardless of whether the first parameter exists. If the first parameter is missing, the second parameter is deleted.
|-
| <code>rename</code> || Rename the first parameter to the second parameter only if the first parameter exists.
|-
| <code>copy</code> || Copy the content of the first parameter to the second parameter only if the first parameter exists; otherwise do nothing.
|-
| <code>spare</code> || Rename the first parameter to the second parameter only if the first parameter exists and the second parameter does not exist; otherwise do nothing.
|-
| <code>provide</code> || Copy the content of the first parameter to the second parameter only if the first parameter exists and the second parameter does not exist; otherwise do nothing.
|-
| <code>sacrifice</code> || Rename the first parameter to the second parameter if the first parameter exists and the second parameter does not exist; if the second parameter already exists, simply delete the first parameter.
|}

{{Note}} When the ''mode'' argument is omitted, as of July 2026, it defaults to <code>transfer</code>. However, this default has changed in the past and may change again in the future. Therefore, we recommend always specifying the ''mode'' argument explicitly.

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params/sandbox|new|
	imposing|foo|bar|
	imposing|hello|world|
	reassigning|foo|test|transfer|
	setting|i/p|<br />| → |
	list
}}</syntaxhighlight>

<div style="width: 100%; height: 1em;"></div>

{{Note}} The modifier name itself and all its arguments are trimmed of their surrounding whitespace.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>discarding</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>discarding</code> <span style="nowrap">({{module:params/doc/link to the code|discarding|code}})</span>
	| Num. of arguments: 1 or 2
	| Repeatable: Yes
	| ; See also
	| : <code>[[#clearing|clearing]]</code>, <code>[[#cutting|cutting]]</code>, <code>[[#cropping|cropping]]</code>, <code>[[#purging|purging]]</code>, <code>[[#backpurging|backpurging]]</code>, <code>[[#splicing|splicing]]</code>, <code>[[#new|new]]</code>
}}

; Brief
: ''Discard one or more numeric parameters or one non-numeric parameter''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|discarding|name|[how many]|pipe function name}}</syntaxhighlight>

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 <code>[[#purging|purging]]</code> or <code>[[#backpurging|backpurging]]</code> or <code>[[#shifting|shifting]]</code>.

Example #1 (discard the parameter named {{para|hello}}):

<syntaxhighlight lang="wikitext">{{#invoke:params|discarding|hello|for_each|[$#: $@]}}</syntaxhighlight>

Example #2 (discard the parameter named {{para|5}}):

<syntaxhighlight lang="wikitext">{{#invoke:params|discarding|5|for_each|[$#: $@]}}</syntaxhighlight>

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

<syntaxhighlight lang="wikitext">{{#invoke:params|discarding|1|4|for_each|[$#: $@]}}</syntaxhighlight>

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

<syntaxhighlight lang="wikitext">{{#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
}}</syntaxhighlight>

You can find this example at &#123;&#123;[[Module:Params/doc/examples/check for unknown parameters|./doc/examples/check for unknown parameters]]&#125;&#125;. For instance, <syntaxhighlight lang="wikitext" inline>{{module:params/doc/examples/check for unknown parameters|hello=world|wind=surfing}}</syntaxhighlight> will generate

: {{module:params/doc/examples/check for unknown parameters|hello=world|wind=surfing}}

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

* {{ml|Check for unknown parameters|check}}
* {{ml|Check for deprecated parameters|check}}
* {{ml|Check for clobbered parameters|check}}
* {{ml|Parameter validation|validateparams}}
* {{ml|TemplatePar|valid}}

When used to discard single parameters, this modifier is equivalent to writing <code>...&#124;[[#with_name_not_matching|with_name_not_matching]]&#124;''parameter name''&#124;strict&#124;...</code>. However, due to the fact that <code>[[#with_name_not_matching|with_name_not_matching]]</code> needs to cross-check for the possible presence of <code>or</code> keywords, using <code>discarding</code> will be slightly more efficient.

{{Note}} All arguments passed to this modifier and the <code>discarding</code> modifier name itself will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>excluding_non-numeric_names</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>excluding_non-numeric_names</code> <span style="nowrap">({{module:params/doc/link to the code|excluding_non-numeric_names|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#excluding_non-numeric_names|excluding_non-numeric_names]]</code>, <code>[[#with_name_matching|with_name_matching]]</code>, <code>[[#with_name_not_matching|with_name_not_matching]]</code>, <code>[[#clearing|clearing]]</code>
}}

; Brief
: ''Discard all non-numeric parameters''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|excluding_non-numeric_names|pipe function name}}</syntaxhighlight>

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>excluding_numeric_names</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>excluding_numeric_names</code> <span style="nowrap">({{module:params/doc/link to the code|excluding_numeric_names|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#excluding_non-numeric_names|excluding_non-numeric_names]]</code>, <code>[[#with_name_matching|with_name_matching]]</code>, <code>[[#with_name_not_matching|with_name_not_matching]]</code>
}}

; Brief
: ''Discard all numeric parameters (not only the sequential ones)''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|excluding_numeric_names|pipe function name}}</syntaxhighlight>

This modifier is only syntax sugar for <code>...&#124;with_name_not_matching&#124;^%-?%d+$&#124;...</code> (but using a slighly faster optimization). For the inverse modifier, see <code>[[#excluding_non-numeric_names|excluding_non-numeric_names]]</code>.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>with_name_matching</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>with_name_matching</code> <span style="nowrap">({{module:params/doc/link to the code|with_name_matching|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Repeatable: Yes
	| ; See also
	| : <code>[[#excluding_numeric_names|excluding_numeric_names]]</code>, <code>[[#excluding_non-numeric_names|excluding_non-numeric_names]]</code>, <code>[[#with_name_not_matching|with_name_not_matching]]</code>, <code>[[#with_value_matching|with_value_matching]]</code>, <code>[[#with_value_not_matching|with_value_not_matching]]</code>, <code>[[#keeping_at_most|keeping_at_most]]</code>
}}

; Brief
: ''Discard all parameters whose name ''does not match '''any''''' of the given patterns''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#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}}</syntaxhighlight>

Internally this modifier uses Lua's <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#string.find|string.find()]]</code> function to find whether parameter names match against given patterns; therefore, unless a ''plain flag'' is set, please use the same syntax of [[:w:en::mw:Extension:Scribunto/Lua reference manual#Patterns|Lua patterns]]. The ''plain flag'' can be either <code>plain</code> or <code>strict</code> or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between <code>plain</code> and <code>strict</code> 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 <code>pattern</code> keyword is available too, equivalent to omitting the argument.

To express a [[:w:en:Disjunction (logical connective)|logical OR]] the <code>or</code> keyword is available. To express a [[:w:en:Logical conjunction|logical AND]] instead, concatenate more invocations of <code>with_name_matching</code>.

<div style="width: 100%; height: 1em;"></div>

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

<syntaxhighlight lang="wikitext">{{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 =
}}</syntaxhighlight>

<div style="width: 100%; height: 1em;"></div>

Test cases:

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

<div style="width: 100%; height: 1em;"></div>

Using <code>with_name_matching</code> 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 <code>&#124;foobar1</code>, <code>&#124;foobar2</code> … <code>&#124;foobarN</code>:

<syntaxhighlight lang="wikitext">{{#invoke:params|all_sorted|with_name_matching|^foobar%d+$|setting|ih|
* |list_values}}</syntaxhighlight>

It is possible to see this example live at &#123;&#123;[[Module:Params/doc/examples/enumerate|./doc/examples/enumerate]]&#125;&#125;.

<div style="width: 100%; height: 1em;"></div>

{{Note}} The ''target'' arguments passed to this modifier will not be trimmed of their leading and trailing spaces. The <code>or</code>, <code>plain</code>, <code>strict</code> and <code>pattern</code> keywords, and the <code>with_name_matching</code> modifier name itself, instead, will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>with_name_not_matching</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>with_name_not_matching</code> <span style="nowrap">({{module:params/doc/link to the code|with_name_not_matching|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Repeatable: Yes
	| ; See also
	| : <code>[[#excluding_numeric_names|excluding_numeric_names]]</code>, <code>[[#excluding_non-numeric_names|excluding_non-numeric_names]]</code>,<code>[[#with_name_matching|with_name_matching]]</code>, <code>[[#with_value_matching|with_value_matching]]</code>, <code>[[#with_value_not_matching|with_value_not_matching]]</code>, <code>[[#keeping_at_most|keeping_at_most]]</code>
}}

; Brief
: ''Discard all parameters whose name ''matches '''all''''' the given patterns''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#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}}</syntaxhighlight>

Internally this modifier uses Lua's <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#string.find|string.find()]]</code> function to find whether parameter names match against given patterns; therefore, unless a plain flag is set, please use the same syntax of [[:w:en::mw:Extension:Scribunto/Lua reference manual#Patterns|Lua patterns]]. The plain flag can be either <code>plain</code> or <code>strict</code> or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between <code>plain</code> and <code>strict</code> 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 <code>pattern</code> keyword is available too, equivalent to omitting the argument.

To express a [[:w:en:Disjunction (logical connective)|logical OR]] the <code>or</code> keyword is available. To express a [[:w:en:Logical conjunction|logical AND]] instead, concatenate more invocations of <code>with_name_not_matching</code>.

<div style="width: 100%; height: 1em;"></div>

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

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

<div style="width: 100%; height: 1em;"></div>

{{Note}} For the sake of efficiency, please don't use this modifier with the <code>strict</code> flag unless accompanied by <code>or</code>, use <code>[[#discarding|discarding]]</code> instead!

{{Note}} The ''target'' arguments passed to this modifier will not be trimmed of their leading and trailing spaces. The <code>or</code>, <code>plain</code>, <code>strict</code> and <code>pattern</code> keywords, and the <code>with_name_not_matching</code> modifier name itself, instead, will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>with_value_matching</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>with_value_matching</code> <span style="nowrap">({{module:params/doc/link to the code|with_value_matching|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Repeatable: Yes
	| ; See also
	| : <code>[[#with_name_matching|with_name_matching]]</code>, <code>[[#with_name_not_matching|with_name_not_matching]]</code>, <code>[[#with_value_not_matching|with_value_not_matching]]</code>, <code>[[#keeping_at_most|keeping_at_most]]</code>
}}

; Brief
: ''Discard all parameters whose value ''does not match '''any''''' of the given patterns''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#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}}</syntaxhighlight>

Exactly like <code>[[#with_name_matching|with_name_matching]]</code>, but applied to parameter values instead of names.

Internally this modifier uses Lua's <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#string.find|string.find()]]</code> function to find whether parameter names match against given patterns; therefore, unless a plain flag is set, please use the same syntax of [[:w:en::mw:Extension:Scribunto/Lua reference manual#Patterns|Lua patterns]]. The plain flag can be either <code>plain</code> or <code>strict</code> or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between <code>plain</code> and <code>strict</code> 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 <code>pattern</code> keyword is available too, equivalent to omitting the argument.

Example:

<syntaxhighlight lang="wikitext">{{#invoke:params|with_value_matching|banana|count}}</syntaxhighlight>

<div style="width: 100%; height: 1em;"></div>

{{Note}} The ''target'' arguments passed to this modifier will not be trimmed of their leading and trailing spaces. The <code>or</code>, <code>plain</code>, <code>strict</code> and <code>pattern</code> keywords, and the <code>with_value_matching</code> modifier name itself, instead, will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>with_value_not_matching</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>with_value_not_matching</code> <span style="nowrap">({{module:params/doc/link to the code|with_value_not_matching|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Repeatable: Yes
	| ; See also
	| : <code>[[#with_name_matching|with_name_matching]]</code>, <code>[[#with_name_not_matching|with_name_not_matching]]</code>, <code>[[#with_value_matching|with_value_matching]]</code>, <code>[[#keeping_at_most|keeping_at_most]]</code>
}}

; Brief
: ''Discard all parameters whose value ''matches '''all''''' the given patterns''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#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}}</syntaxhighlight>

Exactly like <code>[[#with_name_not_matching|with_name_not_matching]]</code>, but applied to parameter values instead of names.

Internally this modifier uses Lua's <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#string.find|string.find()]]</code> function to find whether parameter names match against given patterns; therefore, unless a plain flag is set, please use the same syntax of [[:w:en::mw:Extension:Scribunto/Lua reference manual#Patterns|Lua patterns]]. The plain flag can be either <code>plain</code> or <code>strict</code> or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between <code>plain</code> and <code>strict</code> 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 <code>pattern</code> keyword is available too, equivalent to omitting the argument.

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

<syntaxhighlight lang="wikitext">{{#invoke:params|with_value_not_matching|^%s*$|setting|hi/p|{{!}}|{{=}}|list}}</syntaxhighlight>

A typical use case of this modifier is that of purging all empty incoming parameters before calling another template, especially when this [[:w:en:Help:Conditional expressions#Checking for template parameters|distinguishes between empty and undefined parameters]].

<syntaxhighlight lang="wikitext">{{#invoke:params|with_value_not_matching|^%s*$|concat_and_call|my template}}</syntaxhighlight>

<div style="width: 100%; height: 1em;"></div>

{{Note}} The ''target'' arguments passed to this modifier will not be trimmed of their leading and trailing spaces. The <code>or</code>, <code>plain</code>, <code>strict</code> and <code>pattern</code> keywords, and the <code>with_value_not_matching</code> modifier name itself, instead, will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>keeping_at_most</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>keeping_at_most</code> <span style="nowrap">({{module:params/doc/link to the code|keeping_at_most|code}})</span>
	| Num. of arguments: 1
	| Repeatable: Yes
	| ; See also
	| : <code>[[#with_name_matching|with_name_matching]]</code>, <code>[[#with_name_not_matching|with_name_not_matching]]</code>, <code>[[#with_value_matching|with_value_matching]]</code>, <code>[[#with_value_not_matching|with_value_not_matching]]</code>
}}

; Brief
: ''Reduce the number of current parameters to at most a given number''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|keeping_at_most|number of parameters|pipe function name}}</syntaxhighlight>

This modifier reduces the number of current parameters to at most a given number. First sequential parameters will be picked; then the remaining parameters will be taken in an arbitrary order, which may vary between page parses.

<div style="width: 100%; height: 1em;"></div>

{{Note}} The ''number of parameters'' argument and the <code>keeping_at_most</code> modifier name will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>trimming_values</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>trimming_values</code> <span style="nowrap">({{module:params/doc/link to the code|trimming_values|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
}}

; Brief
: ''Remove leading and trailing spaces from values''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|trimming_values|pipe function name}}</syntaxhighlight>

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

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

<syntaxhighlight lang="wikitext">{{#invoke:params|with_value_matching|%s+$|trimming_values|setting|i/p|{{!}}|{{=}}|list}}</syntaxhighlight>

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

<syntaxhighlight lang="wikitext">{{#invoke:params|trimming_values|with_value_matching|%s+$|setting|i/p|{{!}}|{{=}}|list}}</syntaxhighlight>

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 <code>trimming_values</code> is placed. For instance, if a template were invoked with 50 parameters and its code contained <syntaxhighlight lang="wikitext" inline>{{#invoke:params|trimming_values|cutting|-1|0|list}}</syntaxhighlight>, 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 <syntaxhighlight lang="wikitext" inline>{{#invoke:params|cutting|-1|0|trimming_values|list}}</syntaxhighlight> would first discard 49 parameters and then trim the only value left, resulting in a more efficient code. As a general rule, placing <code>trimming_values</code> as the last modifier is usually the best choice.

In most cases placing <code>trimming_values</code> together with <code>non-sequential</code> 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 <code>trimming_values</code> makes this module behave like other Wikipedia modules behave. For example, if we wanted to emulate {{ml|Separated entries|main}}, writing

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|trimming_values|with_value_not_matching||strict|squeezing|setting|i|XXXX|list_values}}</syntaxhighlight>

will be equivalent to writing,

<syntaxhighlight lang="wikitext">{{#invoke:separated entries|main|separator=XXXX}}</syntaxhighlight>

whereas writing

<syntaxhighlight lang="wikitext">{{#invoke:params|sequential|trimming_values|with_value_not_matching||strict|squeezing|setting|i/l|XXXX|YYYY|list_values}}</syntaxhighlight>

will be equivalent to writing

<syntaxhighlight lang="wikitext">{{#invoke:separated entries|main|separator=XXXX|conjunction=YYYY}}</syntaxhighlight>

The &#123;&#123;[[Module:Params/doc/examples/trim and call|./doc/examples/trim and call]]&#125;&#125; example template shows how to call any arbitrary template trimming all parameters beforehand.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>mapping_to_lowercase</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>mapping_to_lowercase</code> <span style="nowrap">({{module:params/doc/link to the code|mapping_to_lowercase|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>
}}

; Brief
: ''Convert all parameter values to lower case''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|mapping_to_lowercase|pipe function name}}</syntaxhighlight>

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

This modifier converts all parameter values to lower [[:w:en:Letter case|case]]. It is identical to writing <code>...&#124;[[#mapping_by_magic|mapping_by_magic]]&#124;[[:w:en::mw:Help:Magic words#lc|lc]]&#124;...</code>, but without the burden of calling a parser function.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>mapping_to_uppercase</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>mapping_to_uppercase</code> <span style="nowrap">({{module:params/doc/link to the code|mapping_to_uppercase|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>
}}

; Brief
: ''Convert all parameter values to upper case''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|mapping_to_uppercase|pipe function name}}</syntaxhighlight>

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

This modifier converts all parameter values to upper [[:w:en:Letter case|case]]. It is identical to writing <code>...&#124;[[#mapping_by_magic|mapping_by_magic]]&#124;[[:w:en::mw:Help:Magic words#uc|uc]]&#124;...</code>, but without the burden of calling a parser function.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>mapping_by_calling</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>mapping_by_calling</code> <span style="nowrap">({{module:params/doc/link to the code|mapping_by_calling|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#call_for_each|call_for_each]]</code>, <code>[[#call_for_each_value|call_for_each_value]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>
}}

; Brief
: ''[[:w:en:Map (higher-order function)|Map]] all parameter values, replacing their content with the expansion of a given template repeatedly called with one parameter (the parameter's value)''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|mapping_by_calling|template name|[call style]|[let/use]|[...]|[let/use]|[...]|[number of additional parameters]|[parameter 1]|[parameter 2]|[...]|[parameter N]|pipe function name}}</syntaxhighlight>

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 <code>let</code> and/or <code>use</code> keywords (i.e. <code>let&#124;name&#124;value</code>, and/or <code>use&#124;new name&#124;old name</code>), which will be passed to the mapping template as constant parameters. The <code>let</code> keyword declares literal strings, whereas the <code>use</code> keyword exposes pipeline parameters that will no longer be iterated over.

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 as numeric names greater than zero.

In case of collisions, the parameters assigned via the <code>let</code> or <code>use</code> keywords will be given precedence over everything else.

For instance, before listing all parameters,

<syntaxhighlight lang="wikitext">{{#invoke:params|mapping_by_calling|foobar|setting|i/p|{{!}}|{{=}}|list}}</syntaxhighlight>

will replace each value with the expansion of <syntaxhighlight lang="wikitext" inline>{{foobar|VALUE}}</syntaxhighlight> (where <code>VALUE</code> indicates each different value).

On the other hand,

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

will do the same, but using the expansion of <syntaxhighlight lang="wikitext" inline>{{foobar|NAME|VALUE|hello|world|rice=nope|curry=lots!}}</syntaxhighlight> (where <code>NAME</code> and <code>VALUE</code> indicate each different name and value).

Possible ''call style flags'' are:

{| class="wikitable"
|-
! ''Call style flag''
! Example
! Corresponding call
|-
| <code>names_and_values</code>
| <syntaxhighlight lang="wikitext" inline>{{#invoke:params|imposing|wind|surf|mapping_by_calling|example template|names_and_values|let|foo|bar|use|more wind|wind|2|hello|world|setting|i/p|<br />| → |list}}</syntaxhighlight>
| <syntaxhighlight lang="wikitext" inline>{{example template|NAME|VALUE|hello|world|foo=bar|more wind=surf}}</syntaxhighlight>
|-
| <code>values_and_names</code>
| <syntaxhighlight lang="wikitext" inline>{{#invoke:params|imposing|wind|surf|mapping_by_calling|example template|values_and_names|let|foo|bar|use|more wind|wind|2|hello|world|setting|i/p|<br />| → |list}}</syntaxhighlight>
| <syntaxhighlight lang="wikitext" inline>{{example template|VALUE|NAME|hello|world|foo=bar|more wind=surf}}</syntaxhighlight>
|-
| <code>names_only</code>
| <syntaxhighlight lang="wikitext" inline>{{#invoke:params|imposing|wind|surf|mapping_by_calling|example template|names_only|let|foo|bar|use|more wind|wind|2|hello|world|setting|i/p|<br />| → |list}}</syntaxhighlight>
| <syntaxhighlight lang="wikitext" inline>{{example template|NAME|hello|world|foo=bar|more wind=surf}}</syntaxhighlight>
|-
| <code>values_only</code>
| <syntaxhighlight lang="wikitext" inline>{{#invoke:params|imposing|wind|surf|mapping_by_calling|example template|values_only|let|foo|bar|use|more wind|wind|2|hello|world|setting|i/p|<br />| → |list}}</syntaxhighlight>
| <syntaxhighlight lang="wikitext" inline>{{example template|VALUE|hello|world|foo=bar|more wind=surf}}</syntaxhighlight>
|-
| <code>names_and_values_as&#124;...&#124;...</code>
| <syntaxhighlight lang="wikitext" inline>{{#invoke:params|imposing|wind|surf|mapping_by_calling|example template|names_and_values_as|my_name|my_value|let|foo|bar|use|more wind|wind|2|hello|world|setting|i/p|<br />| → |list}}</syntaxhighlight>
| <syntaxhighlight lang="wikitext" inline>{{example template|hello|world|my_name=NAME|my_value=VALUE|foo=bar}}</syntaxhighlight>
|-
| <code>names_only_as&#124;...</code>
| <syntaxhighlight lang="wikitext" inline>{{#invoke:params|imposing|wind|surf|mapping_by_calling|example template|names_only_as|my_name|let|foo|bar|use|more wind|wind|2|hello|world|setting|i/p|<br />| → |list}}</syntaxhighlight>
| <syntaxhighlight lang="wikitext" inline>{{example template|hello|world|my_name=NAME|foo=bar}}</syntaxhighlight>
|-
| <code>values_only_as&#124;...</code>
| <syntaxhighlight lang="wikitext" inline>{{#invoke:params|imposing|wind|surf|mapping_by_calling|example template|values_only_as|my_value|let|foo|bar|use|more wind|wind|2|hello|world|setting|i/p|<br />| → |list}}</syntaxhighlight>
| <syntaxhighlight lang="wikitext" inline>{{example template|hello|world|my_value=VALUE|foo=bar}}</syntaxhighlight>
|-
| <code>blindly</code>
| <syntaxhighlight lang="wikitext" inline>{{#invoke:params|imposing|wind|surf|mapping_by_calling|example template|blindly|let|foo|bar|use|more wind|wind|2|hello|world|setting|i/p|<br />| → |list}}</syntaxhighlight>
| <syntaxhighlight lang="wikitext" inline>{{example template|hello|world|foo=bar|more wind=surf}}</syntaxhighlight>
|}

If the ''call style flags'' argument is omitted it defaults to <code>values_only</code>.

<div style="width: 100%; height: 1em;"></div>

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>mapping_by_invoking</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>mapping_by_invoking</code> <span style="nowrap">({{module:params/doc/link to the code|mapping_by_invoking|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#invoke_for_each|invoke_for_each]]</code>, <code>[[#invoke_for_each_value|invoke_for_each_value]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>
}}

; Brief
: ''[[:w:en:Map (higher-order function)|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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|mapping_by_invoking|module name|function name|[call style]|[let/use]|[...]|[let/use]|[...]|[number of additional arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe function name}}</syntaxhighlight>

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 <code>[[#mapping_by_calling|mapping_by_calling]]</code> for the list of possible flags). If omitted, the ''call style flags'' argument defaults to <code>values_only</code>.

If the ''call style flag'' or (if omitted) the ''template name'' is followed by one or more groups of three arguments led by the <code>let</code> and/or <code>use</code> keywords (i.e. <code>let&#124;name&#124;value</code>, and/or <code>use&#124;new name&#124;old name</code>), which will be passed to the mapping module function as constant parameters. The <code>let</code> keyword declares literal strings, whereas the <code>use</code> keyword exposes pipeline parameters that will no longer be iterated over.

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 as numeric names greater than zero.

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

For instance, before listing all parameters,

<syntaxhighlight lang="wikitext">{{#invoke:params|mapping_by_invoking|foobar|main|setting|i/p|{{!}}|{{=}}|list}}</syntaxhighlight>

will replace each value with the expansion of <syntaxhighlight lang="wikitext" inline>{{#invoke:foobar|main|VALUE}}</syntaxhighlight> (where <code>VALUE</code> indicates each different value).

On the other hand,

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

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

<div style="width: 100%; height: 1em;"></div>

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>mapping_by_magic</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>mapping_by_magic</code> <span style="nowrap">({{module:params/doc/link to the code|mapping_by_magic|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#magic_for_each|magic_for_each]]</code>, <code>[[#magic_for_each_value|magic_for_each_value]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>
}}

; Brief
: ''[[:w:en:Map (higher-order function)|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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|mapping_by_magic|parser function|[call style]|[let/use]|[...]|[let/use]|[...]|[number of additional arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe function name}}</syntaxhighlight>

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 [[:w:en::mw:Help:Magic words#Parser functions|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 <code>[[#mapping_by_calling|mapping_by_calling]]</code> for the list of possible flags). If omitted, the ''call style flags'' argument defaults to <code>values_only</code>.

If the ''call style flag'' or (if omitted) the ''template name'' is followed by one or more groups of three arguments led by the <code>let</code> and/or <code>use</code> keywords (i.e. <code>let&#124;name&#124;value</code>, and/or <code>use&#124;new name&#124;old name</code>), which will be passed to the parser function as constant parameters. The <code>let</code> keyword declares literal strings, whereas the <code>use</code> keyword exposes pipeline parameters that will no longer be iterated over.

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 as numeric names greater than zero.

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

For instance, before listing all parameters,

<syntaxhighlight lang="wikitext">{{#invoke:params|mapping_by_magic|uc|setting|i/p|{{!}}|{{=}}|list}}</syntaxhighlight>

will replace each value with the expansion of <syntaxhighlight lang="wikitext" inline>{{uc:VALUE}}</syntaxhighlight> (where <code>VALUE</code> indicates each different value).

On the other hand,

<syntaxhighlight lang="wikitext">{{#invoke:params|mapping_by_magic|plural|names_and_values|1|They are many|setting|i/p|{{!}}|{{=}}|list}}</syntaxhighlight>

will do the same, but using the expansion of <syntaxhighlight lang="wikitext" inline>{{plural:NAME|VALUE|They are many}}</syntaxhighlight> (where <code>NAME</code> and <code>VALUE</code> indicate each different name and value).

<div style="width: 100%; height: 1em;"></div>

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>mapping_by_replacing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>mapping_by_replacing</code> <span style="nowrap">({{module:params/doc/link to the code|mapping_by_replacing|code}})</span>
	| Num. of arguments: 2–4
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_by_mixing|mapping_by_mixing]]</code>, <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#renaming_by_mixing|renaming_by_mixing]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>, <code>[[#mixing_names_and_values|mixing_names_and_values]]</code>
}}

; Brief
: ''[[:w:en:Map (higher-order function)|Map]] all parameter values performing [[:w:en:String operations#String substitution|string substitutions]]''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|mapping_by_replacing|target|replace|[count]|[plain flag]|pipe function name}}</syntaxhighlight>

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 {{mfl|string|replace}}.

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

The ''count'' argument prescribes how many substitutions will be performed at most ''within each parameter'' (it does not count how many parameters will be modified). If blank or omitted, all matches found will be substituted.

This modifier uses <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#string.gsub|string.gsub()]]</code> for performance reasons; if you need to use <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#mw.ustring.gsub|mw.ustring.gsub()]]</code> instead, you will need to invoke the <code>[[:w:en:Module:String#replace|replace]]</code> function from [[Module:String]] via <code>...&#124;[[#mapping_by_invoking|mapping_by_invoking]]&#124;[[:w:en:Module:String|string]]&#124;[[:w:en:Module:String#replace|replace]]&#124;...</code>.

The following table shows examples of equivalent instructions. Please be aware that invoking <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#mw.ustring.gsub|mw.ustring.gsub()]]</code> can be much slower.

{| class="wikitable"
|-
! <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#string.gsub|string.gsub()]]</code>
! <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#mw.ustring.gsub|mw.ustring.gsub()]]</code> (via [[Module:String]])
|-
| <code>...&#124;mapping_by_replacing&#124;target&#124;replace&#124;...</code>
| <code>...&#124;mapping_by_invoking&#124;string&#124;replace&#124;4&#124;target&#124;replace&#124;&#124;false&#124;...</code>
|-
| <code>...&#124;mapping_by_replacing&#124;target&#124;replace&#124;count&#124;...</code>
| <code>...&#124;mapping_by_invoking&#124;string&#124;replace&#124;4&#124;target&#124;replace&#124;count&#124;false&#124;...</code>
|-
| <code>...&#124;mapping_by_replacing&#124;target&#124;replace&#124;plain&#124;...</code>
| <code>...&#124;mapping_by_invoking&#124;string&#124;replace&#124;2&#124;target&#124;replace&#124;...</code><br />or, equivalently,<br /><code>...&#124;mapping_by_invoking&#124;string&#124;replace&#124;4&#124;target&#124;replace&#124;&#124;true&#124;...</code>
|-
| <code>...&#124;mapping_by_replacing&#124;target&#124;replace&#124;count&#124;plain&#124;...</code>
| <code>...&#124;mapping_by_invoking&#124;string&#124;replace&#124;3&#124;target&#124;replace&#124;count&#124;...</code><br />or, equivalently,<br /><code>...&#124;mapping_by_invoking&#124;string&#124;replace&#124;4&#124;target&#124;replace&#124;count&#124;true&#124;...</code>
|}

There is not a corresponding translation for the <code>strict</code> flag in [[Module:String]]. However, as it goes with the <code>plain</code> flag, in that case you won't need <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#mw.ustring.gsub|mw.ustring.gsub()]]</code> in the first place.

For example,

<syntaxhighlight lang="wikitext">...|mapping_by_renaming|foo|bar|1|...</syntaxhighlight>

will be equivalent to writing

<syntaxhighlight lang="wikitext">...|mapping_by_invoking|string|replace|4|foo|bar|1|false|...</syntaxhighlight>

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

At &#123;&#123;[[Module:Params/doc/examples/informal tablebox|./doc/examples/informal tablebox]]&#125;&#125; you can find an example on how to exploit this function to create "informal" [[:w:en:Template:Infobox|infoboxes]].

<div style="width: 100%; height: 1em;"></div>

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>mapping_by_mixing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>mapping_by_mixing</code> <span style="nowrap">({{module:params/doc/link to the code|mapping_by_mixing|code}})</span>
	| Num. of arguments: 1
	| Repeatable: Yes
	| ; See also
	| : <!--<code>[[#mapping_to_names|mapping_to_names]]</code>, --><code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#renaming_by_mixing|renaming_by_mixing]]</code><!--, <code>[[#renaming_to_values|renaming_to_values]]</code>-->, <code>[[#grouping_by_calling|grouping_by_calling]]</code>, <code>[[#mixing_names_and_values|mixing_names_and_values]]</code><!--, <code>[[#swapping_names_and_values|swapping_names_and_values]]</code>-->
}}

; Brief
: ''[[:w:en:Map (higher-order function)|Map]] all parameter values replacing their current values with the expansion of a custom string containing the <code>$#</code> and <code>$@</code> placeholders''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|mapping_by_mixing|mixing string|pipe function name}}</syntaxhighlight>

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 <code>[[#for_each|for_each]]</code> function.

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

<syntaxhighlight lang="wikitext">...|mapping_by_mixing|"$@"|...</syntaxhighlight>

whereas the following code will replace all values with the string <code>&#91;NAME::VALUE&#93;</code>, where <code>NAME</code> and <code>VALUE</code> are each parameter's name and value:

<syntaxhighlight lang="wikitext">...|mapping_by_mixing|[$#::$@]|...</syntaxhighlight>
<!--
If you need to map all parameters exactly matching their names, please use <code>[[#mapping_to_names|mapping_to_names]]</code>.
-->
<div style="width: 100%; height: 1em;"></div>

{{Note}} The ''mixing string'' argument passed to this modifier will not be trimmed of its leading and trailing spaces. The <code>mapping_by_mixing</code> modifier name itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>
<!--
=== <code>mapping_to_names</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>mapping_to_names</code> <span style="nowrap">({{module:params/doc/link to the code|mapping_to_names|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_by_mixing|mapping_by_mixing]]</code>, <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#renaming_by_mixing|renaming_by_mixing]]</code>, <code>[[#renaming_to_values|renaming_to_values]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>, <code>[[#mixing_names_and_values|mixing_names_and_values]]</code>, <code>[[#swapping_names_and_values|swapping_names_and_values]]</code>
}}

; Brief
: ''[[:w:en:Map (higher-order function)|Map]] all parameter values, replacing the latter with their parameter name''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|mapping_to_names|pipe function name}}</syntaxhighlight>

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

After calling this modifier, all parameters will have their value identical to their name. It is a shortcut for <code>...&#124;[[#mapping_by_mixing|mapping_by_mixing]]&#124;$#&#124;...</code>, but slightly more efficient.

<div style="width: 100%; height: 1em;"></div>

{{Note}} The <code>mapping_to_names</code> modifier name will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>
-->

=== <code>renaming_to_lowercase</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>renaming_to_lowercase</code> <span style="nowrap">({{module:params/doc/link to the code|renaming_to_lowercase|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>
}}

; Brief
: ''Convert all parameter names to lower case''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|renaming_to_lowercase|pipe function name}}</syntaxhighlight>

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

This modifier converts all parameter names to lower [[:w:en:Letter case|case]]. It is identical to writing <code>...&#124;[[#renaming_by_magic|renaming_by_magic]]&#124;[[:w:en::mw:Help:Magic words#lc|lc]]&#124;...</code>, 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.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>renaming_to_uppercase</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>renaming_to_uppercase</code> <span style="nowrap">({{module:params/doc/link to the code|renaming_to_uppercase|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>
}}

; Brief
: ''Convert all parameter names to upper case''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|renaming_to_uppercase|pipe function name}}</syntaxhighlight>

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

This modifier converts all parameter names to upper [[:w:en:Letter case|case]]. It is identical to writing <code>...&#124;[[#renaming_by_magic|renaming_by_magic]]&#124;[[:w:en::mw:Help:Magic words#uc|uc]]&#124;...</code>, 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.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>renaming_to_sequence</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>renaming_to_sequence</code> <span style="nowrap">({{module:params/doc/link to the code|renaming_to_sequence|code}})</span>
	| Num. of arguments: 0–1 (variable)
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>
}}

; Brief
: ''Rename all parameter names using sequential integers and possibly following a sort order''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|renaming_to_sequence|[sort order]|pipe function name}}</syntaxhighlight>

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 <code>alphabetically</code>, <code>naturally</code> (for [[:w:en:natural sort order|natural sort order]]) and <code>without_sorting</code>. When omitted it defaults to <code>without_sorting</code>.

'''Wikitext:'''

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

'''Effect:'''

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

<div style="width: 100%; height: 1em;"></div>

'''Wikitext:'''

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

'''Effect:'''

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

<div style="width: 100%; height: 1em;"></div>

{{Note}} The <code>renaming_to_sequence</code> modifier name and the ''sort order'' argument will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>renaming_by_calling</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>renaming_by_calling</code> <span style="nowrap">({{module:params/doc/link to the code|renaming_by_calling|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>
}}

; 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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|renaming_by_calling|template name|[call style]|[let/use]|[...]|[let/use]|[...]|[number of additional parameters]|[parameter 1]|[parameter 2]|[...]|[parameter N]|pipe function name}}</syntaxhighlight>

This modifier works similarly to <code>[[#mapping_by_calling|mapping_by_calling]]</code>, 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 <code>names_only</code>.

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

<syntaxhighlight lang="wikitext">{{#invoke:params|setting|h/i/p/f|[|][|: |]|renaming_by_calling|2x|list}}</syntaxhighlight>

Same, but adding a hyphen in between:

<syntaxhighlight lang="wikitext">{{#invoke:params|setting|h/i/p/f|[|][|: |]|renaming_by_calling|2x|1|-|list}}</syntaxhighlight>

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

<syntaxhighlight lang="wikitext">{{#invoke:params|renaming_by_calling|P1|values_only|for_each|[$#: $@]}}</syntaxhighlight>

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

<div style="width: 100%; height: 1em;"></div>

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>renaming_by_invoking</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>renaming_by_invoking</code> <span style="nowrap">({{module:params/doc/link to the code|renaming_by_invoking|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>
}}

; 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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|renaming_by_invoking|module name|function name|[call style]|[let/use]|[...]|[let/use]|[...]|[number of additional arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe function name}}</syntaxhighlight>

This modifier works similarly to <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, 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 <code>names_only</code>.

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

<syntaxhighlight lang="wikitext">{{#invoke:params|setting|h/i/p/f|[|][|: |]|with_name_matching|^%a$|renaming_by_invoking|string|rep|1|3|list}}</syntaxhighlight>

<div style="width: 100%; height: 1em;"></div>

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>renaming_by_magic</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>renaming_by_magic</code> <span style="nowrap">({{module:params/doc/link to the code|renaming_by_magic|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>
}}

; 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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|renaming_by_magic|parser function|[call style]|[let/use]|[...]|[let/use]|[...]|[number of additional arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe function name}}</syntaxhighlight>

This modifier works similarly to <code>[[#mapping_by_magic|mapping_by_magic]]</code>, 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 <code>names_only</code>.

For instance, the following example uses &#123;&#123;[[:w:en::mw:Special:MyLanguage/expr##expr|#expr]]&#125;&#125; to transform all numeric parameters into even numbers (you can replace the expression <code>%0 * 2</code> with any other expression):

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

An example that uses this function with the {{Magic word|REVISIONTIMESTAMP}} magic word is available at &#123;&#123;[[Module:Params/doc/examples/watchlist|./doc/examples/watchlist]]&#125;&#125;.

<div style="width: 100%; height: 1em;"></div>

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>renaming_by_replacing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>renaming_by_replacing</code> <span style="nowrap">({{module:params/doc/link to the code|renaming_by_replacing|code}})</span>
	| Num. of arguments: 2–4
	| Repeatable: Yes
	| ; See also
	| : <code>[[#reassigning|reassigning]]</code>, <code>[[#mapping_by_mixing|mapping_by_mixing]]</code>, <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_mixing|renaming_by_mixing]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>, <code>[[#mixing_names_and_values]]</code>
}}

; Brief
: ''Rename all parameters, replacing their former names with the text returned by a [[:w:en:String operations#String substitution|string substitutions]]''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|renaming_by_replacing|target|replace|[count]|[plain flag]|pipe function name}}</syntaxhighlight>

This modifier works similarly to <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, 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 <code>strict</code> flag this modifier directly accesses the requested key without looping through the entire list of parameters (so it will be much faster). For the same reason, doing <code>...&#124;renaming_by_replacing&#124;foo&#124;bar&#124;strict&#124;...</code> and doing <code>...&#124;[[#reassigning|reassigning]]&#124;foo&#124;bar&#124;transfer&#124;...</code> will have identical effect and comparable performance.

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

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

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

For performance reasons this modifier uses <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#string.gsub|string.gsub()]]</code>; if you need to use <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#mw.ustring.gsub|mw.ustring.gsub()]]</code> instead, you will need to invoke the <code>[[:w:en:Module:String#replace|replace]]</code> function from [[Module:String]] via <code>...&#124;[[#renaming_by_invoking|renaming_by_invoking]]&#124;[[Module:String|string]]&#124;[[:w:en:Module:String#replace|replace]]&#124;...</code>.

The following table shows examples of equivalent instructions. Please be aware that invoking <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#mw.ustring.gsub|mw.ustring.gsub()]]</code> can be much slower.

{| class="wikitable"
|-
! <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#string.gsub|string.gsub()]]</code>
! <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#mw.ustring.gsub|mw.ustring.gsub()]]</code> (via [[Module:String]])
|-
| <code>...&#124;renaming_by_replacing&#124;target&#124;replace&#124;...</code>
| <code>...&#124;renaming_by_invoking&#124;string&#124;replace&#124;4&#124;target&#124;replace&#124;&#124;false&#124;...</code>
|-
| <code>...&#124;renaming_by_replacing&#124;target&#124;replace&#124;count&#124;...</code>
| <code>...&#124;renaming_by_invoking&#124;string&#124;replace&#124;4&#124;target&#124;replace&#124;count&#124;false&#124;...</code>
|-
| <code>...&#124;renaming_by_replacing&#124;target&#124;replace&#124;plain&#124;...</code>
| <code>...&#124;renaming_by_invoking&#124;string&#124;replace&#124;2&#124;target&#124;replace&#124;...</code><br />or, equivalently,<br /><code>...&#124;renaming_by_invoking&#124;string&#124;replace&#124;4&#124;target&#124;replace&#124;&#124;true&#124;...</code>
|-
| <code>...&#124;renaming_by_replacing&#124;target&#124;replace&#124;count&#124;plain&#124;...</code>
| <code>...&#124;renaming_by_invoking&#124;string&#124;replace&#124;3&#124;target&#124;replace&#124;count&#124;...</code><br />or, equivalently,<br /><code>...&#124;renaming_by_invoking&#124;string&#124;replace&#124;4&#124;target&#124;replace&#124;count&#124;true&#124;...</code>
|}

There is not a corresponding translation for the <code>strict</code> flag in [[Module:String]]. However, as it goes with the <code>plain</code> flag, in that case you won't need <code>[[:w:en::mw:Extension:Scribunto/Lua reference manual#mw.ustring.gsub|mw.ustring.gsub()]]</code> in the first place.

<div style="width: 100%; height: 1em;"></div>

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>renaming_by_mixing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>renaming_by_mixing</code> <span style="nowrap">({{module:params/doc/link to the code|renaming_by_mixing|code}})</span>
	| Num. of arguments: 1
	| Repeatable: Yes
	| ; See also
	| : <code>[[#reassigning|reassigning]]</code><!--, <code>[[#mapping_to_names|mapping_to_names]]</code>-->, <code>[[#mapping_by_mixing|mapping_by_mixing]]</code>, <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code><!--, <code>[[#renaming_to_values|renaming_to_values]]</code>-->, <code>[[#grouping_by_calling|grouping_by_calling]]</code>, <code>[[#mixing_names_and_values|mixing_names_and_values]]</code><!--, <code>[[#swapping_names_and_values|swapping_names_and_values]]</code>-->
}}

; Brief
: ''Rename all parameters, replacing their former names with the expansion of a custom string containing the <code>$#</code> and <code>$@</code> placeholders''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|renaming_by_mixing|mixing string|pipe function name}}</syntaxhighlight>

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 <code>[[#for_each|for_each]]</code> function.

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

<syntaxhighlight lang="wikitext">...|renaming_by_mixing|"$#"|...</syntaxhighlight>

whereas the following code will replace all parameter names with the string <code>&#91;NAME::VALUE&#93;</code>, where <code>NAME</code> and <code>VALUE</code> are each parameter's name and value:

<syntaxhighlight lang="wikitext">...|renaming_by_mixing|[$#::$@]|...</syntaxhighlight>
<!--
If you need to rename all parameters exactly matching their values, please use <code>[[#renaming_to_values|renaming_to_values]]</code>.
-->
<div style="width: 100%; height: 1em;"></div>

{{Note}} The ''mixing string'' argument passed to this modifier will not be trimmed of its leading and trailing spaces. The <code>renaming_by_mixing</code> modifier name itself, instead, will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>
<!--
=== <code>renaming_to_values</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>renaming_to_values</code> <span style="nowrap">({{module:params/doc/link to the code|renaming_to_values|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_names|mapping_to_names]]</code>, <code>[[#mapping_by_mixing|mapping_by_mixing]]</code>, <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#renaming_by_mixing|renaming_by_mixing]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>, <code>[[#mixing_names_and_values|mixing_names_and_values]]</code>, <code>[[#swapping_names_and_values|swapping_names_and_values]]</code>
}}

; Brief
: ''Rename all parameters, replacing their name with their current value''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|renaming_to_values|pipe function name}}</syntaxhighlight>

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

After calling this modifier, all parameters will have their name identical to their value. It is a shortcut for <code>...&#124;[[#renaming_by_mixing|renaming_by_mixing]]&#124;$@&#124;...</code>, but slightly more efficient.

<div style="width: 100%; height: 1em;"></div>

{{Note}} The <code>renaming_to_values</code> modifier name will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>
-->
=== <code>grouping_by_calling</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>grouping_by_calling</code> <span style="nowrap">({{module:params/doc/link to the code|grouping_by_calling|code}})</span>
	| Num. of arguments: ''Ad libitum''
	| Repeatable: Yes<ref>Unless followed by <code>[[#renaming_by_replacing|renaming_by_replacing]]</code> in few bizarre situations, there is virtually no use in calling this modifier more than once.</ref>
	| ; See also
	| : <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#call_for_each_group|call_for_each_group]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>
}}

; 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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|grouping_by_calling|template name|[let/use]|[...]|[let/use]|[...]|[number of additional arguments]|[argument 1]|[argument 2]|[...]|[argument N]|pipe function name}}</syntaxhighlight>

This is the piping version of <code>[[#call_for_each_group|call_for_each_group]]</code>. 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 <code>mapping_*</code> and <code>renaming_*</code> family, it is possible to impose own parameters on the callback template by using the syntax <code>...|[let/use]|[...]|[let/use]|[...]|[number of additional sequential arguments]|[argument 1]|[argument 2]|[...]|[argument N]|...</code>. Unlike the other <code>mapping_*</code> and <code>renaming_*</code> modifiers, however (but like <code>[[#call_for_each_group|call_for_each_group]]</code>), sequential parameters here will not be appended, but will ''replace'' possible parsed parameters.

And so, writing

<syntaxhighlight lang="wikitext">{{#invoke:params|...|grouping_by_calling|MY TEMPLATE|let|foo|bar|let|hello|world|3|one|two|three|list_values}}</syntaxhighlight>

is identical to writing

<syntaxhighlight lang="wikitext">{{#invoke:params|...|call_for_each_group|MY TEMPLATE|foo=bar|hello=world|one|two|three}}</syntaxhighlight>

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 <code>[[#concat_and_call|concat_and_call]]</code> or <code>[[#concat_and_invoke|concat_and_invoke]]</code>) or, if needed, perform further fine-tuning operations concerning the new parameters.

Please refer to the documentation of <code>[[#call_for_each_group|call_for_each_group]]</code> for further information on the parameters passed to the callback template.

<div style="width: 100%; height: 1em;"></div>

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

<div style="width: 100%; height: 1.5em;"></div>

=== <code>parsing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>parsing</code> <span style="nowrap">({{module:params/doc/link to the code|parsing|code}})</span>
	| Num. of arguments: 1–6
	| Repeatable: Yes
	| Often accompanied by: <code>[[#new|new]]</code>
	| ; See also
	| : <code>[[#new|new]]</code>, <code>{{mfl|ArrayList}}</code>, <code>{{tl|Array}}</code>
}}

; Brief
: ''Create new parameters by parsing a parameter string''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|parsing|string to parse|[trim flag]|[iteration delimiter setter]|[...]|[key-value delimiter setter]|[...]|pipe function name}}</syntaxhighlight>

This modifier allows to add an infinity of new parameters by using a parameter string. By default this expects <code>&#124;</code> as separator between parameters and <code>&#61;</code> 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 <code>[[#new|new]]</code> directive often accompanies this modifier.

Examples:

* <syntaxhighlight lang="wikitext" inline>{{#invoke:params|new|parsing|one{{!}}two{{!}}three{{!}}foo{{=}}bar{{!}}hello{{=}}world|for_each|[$#:$@]}}</syntaxhighlight>
*: ↳ {{#invoke:params|new|parsing|one{{!}}two{{!}}three{{!}}foo{{=}}bar{{!}}hello{{=}}world|for_each|[$#:$@]}}
* <syntaxhighlight lang="wikitext" inline>{{#invoke:params|new|parsing|one, two; three. foo: bar, hello: world|trim_all|splitter_pattern|[,;.]|setter_string|:|for_each|[$#:$@]}}</syntaxhighlight>
*: ↳ {{#invoke:params|new|parsing|one, two; three. foo: bar, hello: world|trim_all|splitter_pattern|[,;.]|setter_string|:|for_each|[$#:$@]}}
* <syntaxhighlight lang="wikitext" inline>{{#invoke:params|new|parsing|one/two/ three / foo % bar /hello%world|setter_string|%|trim_none|splitter_string|/|for_each|[$#:$@]}}</syntaxhighlight>
*: ↳ {{#invoke:params|new|parsing|one/two/ three / foo % bar /hello%world|setter_string|%|trim_none|splitter_string|/|for_each|[$#:$@]}}

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: <code>trim_none</code>, <code>trim_named</code>, <code>trim_positional</code>, <code>trim_all</code>. If omitted, it defaults to <code>trim_named</code>.

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 <code>splitter_string</code> or <code>splitter_pattern</code>. If omitted, the two arguments default to <code>splitter_string&#124;&#123;&#123;!&#125;&#125;</code>. 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 <code>setter_string</code> or <code>setter_pattern</code>. If omitted, the two arguments default to <code>setter_string&#124;&#123;&#123;&#61;&#125;&#125;</code>. 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).

{| class="wikitable" style="margin-left: auto; margin-right: auto;"
|+ Possible options
|-
! Setting a trim flag
! Setting an iteration delimiter
! Setting a key-value delimiter
|-
| <code>trim_none</code><br /> <code>trim_named</code><br /> <code>trim_positional</code><br /> <code>trim_all</code>
| <code>splitter_string&#124;...</code><br /> <code>splitter_pattern&#124;...</code>
| <code>setter_string&#124;...</code><br /> <code>setter_pattern&#124;...</code>
|}

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this modifier except the <code>parsing</code> 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.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>reinterpreting</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>reinterpreting</code> <span style="nowrap">({{module:params/doc/link to the code|reinterpreting|code}})</span>
	| Num. of arguments: 1–6
	| Repeatable: Yes
	| ; See also
	| : <code>[[#parsing|parsing]]</code>, <code>{{mfl|ArrayList}}</code>, <code>{{tl|Array}}</code>
}}

; Brief
: ''Use the content of a parameter as a parameter string to parse, after removing the parameter itself''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|reinterpreting|parameter name|[trim flag]|[iteration delimiter setter]|[...]|[key-value delimiter setter]|[...]|pipe function name}}</syntaxhighlight>

This modifier works exactly like <code>[[#parsing|parsing]]</code>, 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:

<syntaxhighlight lang="wikitext">{{#invoke:params|new|pulling|1|reinterpreting|1|splitter_string|,|trim_all|concat_and_call|See also}}</syntaxhighlight>

An example that shows how to use this function to transclude a custom template with custom parameters is available at &#123;&#123;[[Module:Params/doc/examples/constructed transclusion|./doc/examples/constructed transclusion]]&#125;&#125;.

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this modifier except the <code>reinterpreting</code> 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.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>evaluating</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>evaluating</code> <span style="nowrap">({{module:params/doc/link to the code|evaluating|code}})</span>
	| Num. of arguments: 1–6
	| Repeatable: Yes
	| ; See also
	| : <code>[[#parsing|parsing]]</code>, <code>[[#reinterpreting|reinterpreting]]</code>
}}

; Brief
: ''Create new directives by parsing a parameter string''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|evaluating|string to parse|[trim flag]|[iteration delimiter setter]|[...]|[key-value delimiter setter]|[...]|pipe function name}}</syntaxhighlight>

In order to facilitate scripting, the directives wherewith this module is invoked can be added or removed on the fly. The <code>evaluating</code> modifier works exactly like <code>[[#parsing|parsing]]</code>, 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 <code>[[#parsing|parsing]]</code>, here the default separators are <code>!</code> and <code>:</code> instead of <code>&#123;&#123;!&#125;&#125;</code> and <code>&#123;&#123;&#61;&#125;&#125;</code>. Moreover a blank input will be discarded.

'''Example:'''

<syntaxhighlight lang="wikitext">{{#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
}}</syntaxhighlight>

'''Result:'''

: {{#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
}}

{{Note}} All arguments passed to this modifier except the <code>evaluating</code> 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.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>mixing_names_and_values</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>mixing_names_and_values</code> <span style="nowrap">({{module:params/doc/link to the code|mixing_names_and_values|code}})</span>
	| Num. of arguments: 2
	| Repeatable: Yes
	| ; See also
	| : <!--<code>[[#mapping_to_names|mapping_to_names]]</code>, --><code>[[#mapping_by_mixing|mapping_by_mixing]]</code>, <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#renaming_by_mixing|renaming_by_mixing]]</code><!--, <code>[[#renaming_to_values|renaming_to_values]]</code>-->, <code>[[#grouping_by_calling|grouping_by_calling]]</code><!--, <code>[[#swapping_names_and_values|swapping_names_and_values]]</code>-->
}}

; Brief
: ''Rewrite all parameters, replacing  names and values with the expansion of two custom strings containing the <code>$#</code> and <code>$@</code> placeholders''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|mixing_names_and_values|name mixing string|value mixing string|pipe function name}}</syntaxhighlight>

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 <code>[[#for_each|for_each]]</code> function.

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

<syntaxhighlight lang="wikitext">...|mixing_names_and_values|"$#"|"$@"|...</syntaxhighlight>

whereas the following code will replace all names with the string <code>VALUE/NAME</code> and all values with the string <code>&#91;NAME::VALUE&#93;</code>, where <code>NAME</code> and <code>VALUE</code> are each parameter's name and value:

<syntaxhighlight lang="wikitext">...|mixing_names_and_values|$@/$#|[$#::$@]|...</syntaxhighlight>
<!--
If you need to swap names and values verbatim, please use <code>[[#swapping_names_and_values|swapping_names_and_values]]</code>.
-->
<div style="width: 100%; height: 1em;"></div>

{{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 <code>mixing_names_and_values</code> modifier name itself, instead, will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>
<!--
=== <code>swapping_names_and_values</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>swapping_names_and_values</code> <span style="nowrap">({{module:params/doc/link to the code|swapping_names_and_values|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#mapping_to_names|mapping_to_names]]</code>, <code>[[#mapping_by_mixing|mapping_by_mixing]]</code>, <code>[[#mapping_to_lowercase|mapping_to_lowercase]]</code>, <code>[[#mapping_to_uppercase|mapping_to_uppercase]]</code>, <code>[[#mapping_by_calling|mapping_by_calling]]</code>, <code>[[#mapping_by_invoking|mapping_by_invoking]]</code>, <code>[[#mapping_by_magic|mapping_by_magic]]</code>, <code>[[#renaming_to_lowercase|renaming_to_lowercase]]</code>, <code>[[#renaming_to_uppercase|renaming_to_uppercase]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>, <code>[[#renaming_by_calling|renaming_by_calling]]</code>, <code>[[#renaming_by_invoking|renaming_by_invoking]]</code>, <code>[[#renaming_by_magic|renaming_by_magic]]</code>, <code>[[#renaming_by_replacing|renaming_by_replacing]]</code>, <code>[[#renaming_by_mixing|renaming_by_mixing]]</code>, <code>[[#renaming_to_values|renaming_to_values]]</code>, <code>[[#grouping_by_calling|grouping_by_calling]]</code>, <code>[[#mixing_names_and_values|mixing_names_and_values]]</code>
}}

; Brief
: ''Rewrite all parameters swapping their names and values''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|swapping_names_and_values|pipe function name}}</syntaxhighlight>

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

This modifier is a shortcut for <code>...&#124;[[#mixing_names_and_values|mixing_names_and_values]]&#124;$@&#124;$#&#124;...</code>, but slightly more efficient.

<div style="width: 100%; height: 1em;"></div>

{{Note}} The <code>swapping_names_and_values</code> modifier name will be trimmed of its surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>
-->

=== <code>combining</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>combining</code> <span style="nowrap">({{module:params/doc/link to the code|combining|code}})</span>
	| Num. of arguments: 2–10 (variable)
	| Repeatable: Yes
	| ; Memory slots
	| : {{Br separated entries
		| <code>p</code> Key-value delimiter
		| <code>i</code> Iteration delimiter
		| <code>l</code> Last iteration delimiter
		| <code>h</code> Header text
		| <code>f</code> Footer text
		| <code>n</code> Fallback text
		| <code>s</code> “[[:w:en:serial comma|serial-comma]]-like” last iteration delimiter
	}}
	| ; See also
	| : <code>[[#combining_values|combining_values]]</code>, <code>[[#combining_by_calling|combining_by_calling]]</code>, <code>[[#combining_by_invoking|combining_by_invoking]]</code>, <code>[[#combining_by_magic|combining_by_magic]]</code>, <code>[[#list|list]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>
}}

; Brief
: ''Combine all parameter names and values into a single parameter, possibly using a sort order and glue strings''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|combining|new parameter name|[sort order]|[with/without flushed glue]|setting directives|...|pipe function name}}</syntaxhighlight>

This modifier combines all parameter names and values into a single new parameter (whose name can be identical to that of a pre-existing parameter). It can be broadly considered as a “modifier version” of the <code>[[#list|list]]</code> function.

The ''new parameter name'' argument specifies the name of the new parameter that must be created.

The ''sort order'' optional flag argument specifies a sort order. Possible values are <code>alphabetically</code>, <code>naturally</code> (for [[:w:en:natural sort order|natural sort order]]) and <code>without_sorting</code>. When omitted it defaults to <code>without_sorting</code>.

The ''with/without flushed glue'' optional flag specifies whether to flush a substack in order to set glue strings, similarly to what <code>[[#setting_by_flushing|setting_by_flushing]]</code> does. Possible values are <code>with_flushed_glue</code> and <code>without_flushed_glue</code>. When omitted it defaults to <code>without_flushed_glue</code>.

The ''setting directives'' argument is identical to the first argument of the <code>[[#setting|setting]]</code> modifier, and accordingly is followed by a variable number of arguments (up to seven—see <code>[[#setting|setting]]</code> for more information). Differently than in <code>[[#setting|setting]]</code>, here the ''setting directives'' argument can be left empty (but not omitted).

For a similar modifier that combines only values and omits parameter names, see the <code>[[#combining_values|combining_values]]</code> modifier.

'''Wikitext:'''

<syntaxhighlight lang="wikitext">{{#invoke:params|new|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|foo|bar|
	imposing|wind3|ccc|
	imposing|wind1|aaa|
	imposing|wind2|bbb|
	imposing|wind12|ddd|
	entering_substack|
		imposing|i|, |
		imposing|p| → |
	leaving_substack|
	combining|my_new_parameter|naturally|with_flushed_glue|h/l/s/f/n|⟨| and |, and |⟩|NO PARAMETERS ARE PRESENT|
	setting|i/p|<br />| {{=}} |
	list
}}</syntaxhighlight>

'''Effect:'''

: {{#invoke:params|new|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|foo|bar|
	imposing|wind3|ccc|
	imposing|wind1|aaa|
	imposing|wind2|bbb|
	imposing|wind12|ddd|
	entering_substack|
		imposing|i|, |
		imposing|p| → |
	leaving_substack|
	combining|my_new_parameter|naturally|with_flushed_glue|h/l/s/f/n|⟨| and |, and |⟩|NO PARAMETERS ARE PRESENT|
	setting|i/p|<br />| {{=}} |
	list
}}

<div style="width: 100%; height: 1em;"></div>

'''Wikitext:'''

<syntaxhighlight lang="wikitext">{{#invoke:params|new|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|foo|bar|
	imposing|wind3|ccc|
	imposing|wind1|aaa|
	imposing|wind2|bbb|
	imposing|wind12|ddd|
	combining|my_new_parameter|naturally|h/i/p/l/s/f/n|⟨|, | → | and |, and |⟩|NO PARAMETERS ARE PRESENT|
	setting|i/p|<br />| {{=}} |
	list
}}</syntaxhighlight>

'''Effect:'''

: {{#invoke:params|new|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|foo|bar|
	imposing|wind3|ccc|
	imposing|wind1|aaa|
	imposing|wind2|bbb|
	imposing|wind12|ddd|
	combining|my_new_parameter|h/i/p/l/s/f/n|⟨|, | → | and |, and |⟩|NO PARAMETERS ARE PRESENT|
	setting|i/p|<br />| {{=}} |
	list
}}

<div style="width: 100%; height: 1em;"></div>

'''Wikitext:'''

<syntaxhighlight lang="wikitext">{{#invoke:params|new|
	imposing|1|one|
	imposing|2|two|
	imposing|wind3|ccc|
	imposing|wind1|aaa|
	imposing|wind2|bbb|
	imposing|wind12|ddd|
	combining|my_new_parameter||
	setting|i/p|<br />| {{=}} |
	list
}}</syntaxhighlight>

'''Effect:'''

: {{#invoke:params|new|
	imposing|1|one|
	imposing|2|two|
	imposing|wind3|ccc|
	imposing|wind1|aaa|
	imposing|wind2|bbb|
	imposing|wind12|ddd|
	combining|my_new_parameter||
	setting|i/p|<br />| {{=}} |
	list
}}


<div style="width: 100%; height: 1em;"></div>

{{Note}} The <code>combining</code> modifier name, the ''new parameter name'' argument, the ''sort order'' argument and the ''with/without flushed glue'' argument will be trimmed of their surrounding spaces. The ''setting 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).

<div style="width: 100%; height: 1.5em;"></div>

=== <code>combining_values</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>combining_values</code> <span style="nowrap">({{module:params/doc/link to the code|combining_values|code}})</span>
	| Num. of arguments: 2–10 (variable)
	| Repeatable: Yes
	| ; Memory slots
	| : {{Br separated entries
		| <code>i</code> Iteration delimiter
		| <code>l</code> Last iteration delimiter
		| <code>h</code> Header text
		| <code>f</code> Footer text
		| <code>n</code> Fallback text
		| <code>s</code> “[[:w:en:serial comma|serial-comma]]-like” last iteration delimiter
	}}
	| ; See also
	| : <code>[[#combining|combining]]</code>, <code>[[#combining_by_calling|combining_by_calling]]</code>, <code>[[#combining_by_invoking|combining_by_invoking]]</code>, <code>[[#combining_by_magic|combining_by_magic]]</code>, <code>[[#list|list]]</code>, <code>[[#renaming_to_sequence|renaming_to_sequence]]</code>
}}

; Brief
: ''Combine all parameter values into a single parameter, possibly using a sort order and glue strings''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|combining_values|new parameter name|[sort order]|[with/without flushed glue]|setting directives|...|pipe function name}}</syntaxhighlight>

This modifier combines all parameter values into a single new parameter (whose name can be identical to that of a pre-existing parameter). It can be broadly considered as a “modifier version” of the <code>[[#list_values|list_values]]</code> function. Its syntax is identical to that of <code>[[#combining|combining]]</code>; see there for more information.

<div style="width: 100%; height: 1em;"></div>

{{Note}} The <code>combining_values</code> modifier name, the ''new parameter name'' argument, the ''sort order'' argument and the ''with/without flushed glue'' argument will be trimmed of their surrounding spaces. The ''setting 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).

<div style="width: 100%; height: 1.5em;"></div>

=== <code>combining_by_calling</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>combining_by_calling</code> <span style="nowrap">({{module:params/doc/link to the code|combining_by_calling|code}})</span>
	| Num. of arguments: 2
	| Repeatable: Yes
	| ; See also
	| : <code>[[#combining|combining]]</code>, <code>[[#combining_values|combining_values]]</code>, <code>[[#combining_by_invoking|combining_by_invoking]]</code>, <code>[[#combining_by_magic|combining_by_magic]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#concat_and_call|concat_and_call]]</code>
}}

; Brief
: ''Pass all current parameters to a custom template and save the returned output as a new parameter''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|combining_by_calling|template name|new parameter name|pipe function name}}</syntaxhighlight>

This is the piping version of <code>[[#concat_and_call|concat_and_call]]</code>. 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 <code>[[#imposing|imposing]]</code>, <code>[[#providing|providing]]</code>, <code>[[#splicing|splicing]]</code>, or <code>[[#parsing|parsing]]</code>.

For instance, using [[Module:Params/testcases/tdummy echo sb|./testcases/tdummy echo sb]] as callback template, a template named <syntaxhighlight lang="wikitext" inline>{{example template}}</syntaxhighlight> with the following content,

<syntaxhighlight lang="wikitext">{{#invoke:params|combining_by_calling|module:params/testcases/tdummy echo sb|my_new_parameter|for_each|[$#:$@]}}</syntaxhighlight>

when transcluded as <syntaxhighlight lang="wikitext" inline>{{example template|one|two|three|hello=world|foo=bar}}</syntaxhighlight> will produce

: {{#invoke:params|new|
	imposing|1|one|
	imposing|2|two|
	imposing|3|three|
	imposing|hello|world|
	imposing|foo|bar|
	combining_by_calling|module:params/testcases/tdummy echo sb|my_new_parameter|for_each|[$#:$@]}}

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this modifier and the <code>combining_by_calling</code> modifier name will be trimmed of their leading and trailing spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>combining_by_invoking</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>combining_by_invoking</code> <span style="nowrap">({{module:params/doc/link to the code|combining_by_invoking|code}})</span>
	| Num. of arguments: 3
	| Repeatable: Yes
	| ; See also
	| : <code>[[#combining|combining]]</code>, <code>[[#combining_values|combining_values]]</code>, <code>[[#combining_by_calling|combining_by_calling]]</code>, <code>[[#combining_by_magic|combining_by_magic]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#concat_and_call|concat_and_call]]</code>
}}

; Brief
: ''Pass all current parameters to a custom module function and save the returned output as a new parameter''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|combining_by_invoking|module name|function name|new parameter name|pipe function name}}</syntaxhighlight>

This is the piping version of <code>[[#concat_and_invoke|concat_and_invoke]]</code>. It works similarly to how <code>[[#combining_by_calling|combining_by_calling]]</code> 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 <code>[[#imposing|imposing]]</code>, <code>[[#providing|providing]]</code>, <code>[[#splicing|splicing]]</code>, or <code>[[#parsing|parsing]]</code>.

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this modifier and the <code>combining_by_invoking</code> modifier name will be trimmed of their leading and trailing spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>combining_by_magic</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>combining_by_magic</code> <span style="nowrap">({{module:params/doc/link to the code|combining_by_magic|code}})</span>
	| Num. of arguments: 2
	| Repeatable: Yes
	| ; See also
	| : <code>[[#combining|combining]]</code>, <code>[[#combining_values|combining_values]]</code>, <code>[[#combining_by_calling|combining_by_calling]]</code>, <code>[[#combining_by_invoking|combining_by_invoking]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#concat_and_call|concat_and_call]]</code>
}}

; Brief
: ''Pass all current parameters to a parser function and save the returned output as a new parameter''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|combining_by_magic|parser function|new parameter name|pipe function name}}</syntaxhighlight>

This is the piping version of <code>[[#concat_and_magic|concat_and_magic]]</code>. It works similarly to how <code>[[#combining_by_calling|combining_by_calling]]</code> 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 <code>[[#imposing|imposing]]</code>, <code>[[#providing|providing]]</code>, <code>[[#splicing|splicing]]</code>, or <code>[[#parsing|parsing]]</code>.

<div style="width: 100%; height: 1em;"></div>

{{Note}} All arguments passed to this modifier and the <code>combining_by_magic</code> modifier name will be trimmed of their leading and trailing spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>snapshotting</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>snapshotting</code> <span style="nowrap">({{module:params/doc/link to the code|snapshotting|code}})</span>
	| Num. of arguments: 0–1
	| Repeatable: Yes
	| Eventually followed by: Either <code>[[#entering_substack|entering_substack]]</code> or <code>[[#flushing|flushing]]</code>
	| ; See also
	| : <code>[[#remembering|remembering]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#pulling|pulling]]</code>, <code>[[#recalling|recalling]]</code>, <code>[[#merging_substack|merging_substack]]</code>, <code>[[#detaching_substack|detaching_substack]]</code>, <code>[[#dropping_substack|dropping_substack]]</code>, <code>[[#leaving_substack|leaving_substack]]</code>, <code>[[#flushing|flushing]]</code>, <code>[[#setting_by_flushing|setting_by_flushing]]</code>, <code>[[#scoring|scoring]]</code>
}}

; Brief
: ''Push a copy of the current parameter list to the queue of parameter lists''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|snapshotting|[maximum number]|pipe function name}}</syntaxhighlight>

This modifier optionally takes one numeric argument indicating the maximum number of parameters to copy. If omitted, the entire current parameter list will be copied. If provided, sequential parameters will be picked first; then the remaining parameters will be taken in an arbitrary order, which may vary between page parses.

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:

* <code>[[#snapshotting|snapshotting]]</code>
* <code>[[#scoring|scoring]]</code>
* <code>[[#remembering|remembering]]</code>
* <code>[[#entering_substack|entering_substack]]</code>
* <code>[[#pulling|pulling]]</code>
* <code>[[#recalling|recalling]]</code>
* <code>[[#detaching_substack|detaching_substack]]</code>
* <code>[[#dropping_substack|dropping_substack]]</code>
* <code>[[#leaving_substack|leaving_substack]]</code>
* <code>[[#merging_substack|merging_substack]]</code>
* <code>[[#flushing|flushing]]</code>
* <code>[[#setting_by_flushing|setting_by_flushing]]</code>

In addition, the <code>[[#combining|combining]]</code> and <code>[[#combining_values|combining_values]]</code> modifiers have a <code>with_flushed_glue</code> option that lets consume substacks in order to define glue strings (separators, setters, etc.)

Every time the <code>snapshotting</code> modifier is used, the current list of parameters (together with their values) will be copied and added to a queue. When the <code>[[#entering_substack|entering_substack]]</code> 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 <code>[[#merging_substack|merging_substack]]</code> will merge the current substack to the parent stack.

If no parameter lists have been snapshotted before calling <code>[[#entering_substack|entering_substack]]</code>, 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 <code>[[#detaching_substack|detaching_substack]]</code> 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 <code>[[#leaving_substack|leaving_substack]]</code> modifier. In this case, at some point it will be necessary to call <code>[[#flushing|flushing]]</code> in order to merge the stack previously left unmerged. Alternatively, it will be possible to enter it again by calling <code>[[#entering_substack|entering_substack]]</code>, and finally merge it via <code>[[#merging_substack|merging_substack]]</code>. It is also possible to drop and discard a substack completely via <code>[[#dropping_substack|dropping_substack]]</code>

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

<syntaxhighlight lang="wikitext" line>
{{#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|[$#:$@]}}
</syntaxhighlight>

The code above will result in:

: {{#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 all parameters -->
	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 all parameters -->
	merging_substack|
for_each|[$#:$@]}}

A more advanced example is available at &#123;&#123;[[Module:Params/doc/examples/universal page list|./doc/examples/universal page list]]&#125;&#125;.

<div style="width: 100%; height: 1em;"></div>

{{Note}} Both the <code>snapshotting</code> modifier name and the ''maximum number'' argument will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>remembering</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>remembering</code> <span style="nowrap">({{module:params/doc/link to the code|remembering|code}})</span>
	| Num. of arguments: 0–1
	| Repeatable: Yes
	| Eventually followed by: Either <code>[[#entering_substack|entering_substack]]</code> or <code>[[#flushing|flushing]]</code>
	| ; See also
	| : <code>[[#snapshotting|snapshotting]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#pulling|pulling]]</code>, <code>[[#recalling|recalling]]</code>, <code>[[#merging_substack|merging_substack]]</code>, <code>[[#detaching_substack|detaching_substack]]</code>, <code>[[#dropping_substack|dropping_substack]]</code>, <code>[[#leaving_substack|leaving_substack]]</code>, <code>[[#flushing|flushing]]</code>, <code>[[#setting_by_flushing|setting_by_flushing]]</code>, <code>[[#scoring|scoring]]</code>
}}

; Brief
: ''Push a copy of the original (unmodified) parameter list to the queue of snapshots''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|remembering|[maximum number]|pipe function name}}</syntaxhighlight>

This modifier optionally takes one numeric argument indicating the maximum number of parameters to copy. If omitted, the entire original parameter list will be copied. If provided, sequential parameters will be picked first; then the remaining parameters will be taken in an arbitrary order, which may vary between page parses.

This modifier is somewhat similar to <code>[[#snapshotting|snapshotting]]</code>, 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 <code>[[#new|new]]</code> directive. See <code>[[#snapshotting|snapshotting]]</code> for more information on the stacking mechanism.

<div style="width: 100%; height: 1em;"></div>

{{Note}} Both the <code>remembering</code> modifier name and the ''maximum number'' argument will be trimmed of their surrounding spaces.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>entering_substack</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>entering_substack</code> <span style="nowrap">({{module:params/doc/link to the code|entering_substack|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| May be immediately followed by: <code>[[#new|new]]</code>
	| Eventually followed by: Either <code>[[#merging_substack|merging_substack]]</code> or <code>[[#leaving_substack|leaving_substack]]</code> followed by <code>[[#flushing|flushing]]</code>
	| ; See also
	| : <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#pulling|pulling]]</code>, <code>[[#recalling|recalling]]</code>, <code>[[#merging_substack|merging_substack]]</code>, <code>[[#detaching_substack|detaching_substack]]</code>, <code>[[#dropping_substack|dropping_substack]]</code>, <code>[[#leaving_substack|leaving_substack]]</code>, <code>[[#flushing|flushing]]</code>, <code>[[#setting_by_flushing|setting_by_flushing]]</code>, <code>[[#scoring|scoring]]</code>
}}

; 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
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|entering_substack|[new]|pipe function name}}</syntaxhighlight>

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

See <code>[[#snapshotting|snapshotting]]</code> 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: <code>[[#merging_substack|merging_substack]]</code>, <code>[[#leaving_substack|leaving_substack]]</code> and <code>[[#dropping_substack|dropping_substack]]</code>.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>pulling</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>pulling</code> <span style="nowrap">({{module:params/doc/link to the code|pulling|code}})</span>
	| Num. of arguments: 1
	| Repeatable: Yes
	| Often preceeded by: <code>[[#new|new]]</code>
	| ; See also
	| : <code>[[#recalling|recalling]]</code>, <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#merging_substack|merging_substack]]</code>, <code>[[#detaching_substack|detaching_substack]]</code>, <code>[[#dropping_substack|dropping_substack]]</code>, <code>[[#leaving_substack|leaving_substack]]</code>, <code>[[#flushing|flushing]]</code>, <code>[[#setting_by_flushing|setting_by_flushing]]</code>, <code>[[#scoring|scoring]]</code>
}}

; Brief
: ''Pull a single parameter from the parent stack or from the stack of the original parameters''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|pulling|parameter name|pipe function name}}</syntaxhighlight>

See <code>[[#snapshotting|snapshotting]]</code> 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.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>recalling</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>recalling</code> <span style="nowrap">({{module:params/doc/link to the code|recalling|code}})</span>
	| Num. of arguments: 1
	| Repeatable: Yes
	| Often preceeded by: <code>[[#new|new]]</code>
	| ; See also
	| : <code>[[#pulling|pulling]]</code>, <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#merging_substack|merging_substack]]</code>, <code>[[#detaching_substack|detaching_substack]]</code>, <code>[[#dropping_substack|dropping_substack]]</code>, <code>[[#leaving_substack|leaving_substack]]</code>, <code>[[#flushing|flushing]]</code>, <code>[[#setting_by_flushing|setting_by_flushing]]</code>, <code>[[#scoring|scoring]]</code>
}}

; Brief
: ''Pull a single parameter from the original (unmodified) parameters''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|recalling|parameter name|pipe function name}}</syntaxhighlight>

Unlike <code>[[#pulling|pulling]]</code>, <code>recalling</code> always retrieves the parameter from the original (unmodified) parameter stack, regardless of subsequent transformations. See <code>[[#snapshotting|snapshotting]]</code> for more information on the stacking mechanism.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>detaching_substack</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>detaching_substack</code> <span style="nowrap">({{module:params/doc/link to the code|detaching_substack|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| Restrictions: Usable only inside substacks
	| ; See also
	| : <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#pulling|pulling]]</code>, <code>[[#recalling|recalling]]</code>, <code>[[#dropping_substack|dropping_substack]]</code>, <code>[[#merging_substack|merging_substack]]</code>, <code>[[#leaving_substack|leaving_substack]]</code>, <code>[[#flushing|flushing]]</code>, <code>[[#setting_by_flushing|setting_by_flushing]]</code>, <code>[[#scoring|scoring]]</code>
}}

; Brief
: ''Remove from the parent stack the parameters that are present in the current stack''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|detaching_substack|pipe function name}}</syntaxhighlight>

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 <code>[[#snapshotting|snapshotting]]</code> for more information on the stacking mechanism.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>dropping_substack</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>dropping_substack</code> <span style="nowrap">({{module:params/doc/link to the code|dropping_substack|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| Restrictions: Usable only inside substacks
	| ; See also
	| : <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#pulling|pulling]]</code>, <code>[[#recalling|recalling]]</code>, <code>[[#merging_substack|merging_substack]]</code>, <code>[[#leaving_substack|leaving_substack]]</code>, <code>[[#flushing|flushing]]</code>, <code>[[#setting_by_flushing|setting_by_flushing]]</code>, <code>[[#scoring|scoring]]</code>
}}

; Brief
: ''Go back to the parent stack dropping the current substack''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|dropping_substack|pipe function name}}</syntaxhighlight>

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 <code>[[#snapshotting|snapshotting]]</code> for more information on the stacking mechanism.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>leaving_substack</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>leaving_substack</code> <span style="nowrap">({{module:params/doc/link to the code|leaving_substack|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| Restrictions: Usable only inside substacks
	| ; See also
	| : <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#pulling|pulling]]</code>, <code>[[#recalling|recalling]]</code>, <code>[[#merging_substack|merging_substack]]</code>, <code>[[#detaching_substack|detaching_substack]]</code>, <code>[[#dropping_substack|dropping_substack]]</code>, <code>[[#flushing|flushing]]</code, <code>[[#setting_by_flushing|setting_by_flushing]]</code>, <code>[[#scoring|scoring]]</code>>
}}

; Brief
: ''Leave the current substack without merging it, and return to the parent stack''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|leaving_substack|pipe function name}}</syntaxhighlight>

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 <code>[[#snapshotting|snapshotting]]</code> for more information on the stacking mechanism.

See <code>[[#flushing|flushing]]</code> for an example of how to use this modifier.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>merging_substack</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>merging_substack</code> <span style="nowrap">({{module:params/doc/link to the code|merging_substack|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| Restrictions: Usable only inside substacks
	| ; See also
	| : <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#pulling|pulling]]</code>, <code>[[#recalling|recalling]]</code>, <code>[[#detaching_substack|detaching_substack]]</code>, <code>[[#dropping_substack|dropping_substack]]</code>, <code>[[#leaving_substack|leaving_substack]]</code>, <code>[[#flushing|flushing]]</code>, <code>[[#setting_by_flushing|setting_by_flushing]]</code>, <code>[[#scoring|scoring]]</code>
}}

; Brief
: ''Leave the current stack after merging it with the parent stack, then return to the latter''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|merging_substack|pipe function name}}</syntaxhighlight>

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 <code>[[#snapshotting|snapshotting]]</code> for more information on the stacking mechanism.

<div style="width: 100%; height: 1.5em;"></div>

=== <code>flushing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>flushing</code> <span style="nowrap">({{module:params/doc/link to the code|flushing|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#pulling|pulling]]</code>, <code>[[#recalling|recalling]]</code>, <code>[[#merging_substack|merging_substack]]</code>, <code>[[#detaching_substack|detaching_substack]]</code>, <code>[[#dropping_substack|dropping_substack]]</code>, <code>[[#leaving_substack|leaving_substack]]</code>, <code>[[#setting_by_flushing|setting_by_flushing]]</code>, <code>[[#scoring|scoring]]</code>
}}

; Brief
: ''Merge the first stack in the queue of snapshotted parameters with the current stack.''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|flushing|pipe function name}}</syntaxhighlight>

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

This modifier is used in conjunction with either <code>[[#leaving_substack|leaving_substack]]</code> or <code>[[#snapshotting|snapshotting]]</code>. See <code>[[#snapshotting|snapshotting]]</code> for more information on the stacking mechanism.

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

<syntaxhighlight lang="wikitext">{{#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
}}</syntaxhighlight>

<div style="width: 100%; height: 1.5em;"></div>

=== <code>setting_by_flushing</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>setting_by_flushing</code> <span style="nowrap">({{module:params/doc/link to the code|setting_by_flushing|code}})</span>
	| Num. of arguments: 0
	| Repeatable: Yes
	| ; See also
	| : <code>[[#snapshotting|snapshotting]]</code>, <code>[[#remembering|remembering]]</code>, <code>[[#entering_substack|entering_substack]]</code>, <code>[[#pulling|pulling]]</code>, <code>[[#recalling|recalling]]</code>, <code>[[#merging_substack|merging_substack]]</code>, <code>[[#detaching_substack|detaching_substack]]</code>, <code>[[#dropping_substack|dropping_substack]]</code>, <code>[[#leaving_substack|leaving_substack]]</code>, <code>[[#flushing|flushing]]</code>, <code>[[#scoring|scoring]]</code>
}}

; Brief
: ''Use the first stack in the queue of snapshotted parameters as the source of glue strings, then drop the substack.''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|setting_by_flushing|pipe function name}}</syntaxhighlight>

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

The main goal of this modifier is to expose the parameters that are currently in the pipeline to the glue strings normally set by <code>[[#setting|setting]]</code>. It does so by consuming a substack that is expected to contain parameters named <code>h</code>, <code>i</code>, etc. (see <code>[[#setting|setting]]</code> for the complete list). If the substack contains other parameters too, these will be discarded. The strings set in this way can later be overwritten by further calls to <code>setting_by_flushing</code>.

For instance, the following code calls <code>[[#scoring|scoring]]</code> to count the current parameters, then decides whether to show “Your items are” or “Your item is”, depending on whether more than one numeric parameter are present:

<syntaxhighlight lang="wikitext">{{#invoke:params|
	excluding_non-numeric_names|
	scoring|h|in_substack|
	entering_substack|
		mapping_by_magic|PLURAL|2|Your item is:<ul><li>|Your items are:<ul><li>|
	leaving_substack|
	setting_by_flushing|
	setting|i/f|</li><li>|</li></ul>|
	all_sorted|
	list_values
}}</syntaxhighlight>

<div style="width: 100%; height: 1.5em;"></div>

=== <code>new</code> ===
{{module:params/doc/examples/informal tablebox|caption=Modifier <code>new</code> <span style="nowrap">({{module:params/doc/link to the code|new|code}})</span>
	| Num. of arguments: 0
	| Repeatable: No
	| Restrictions: First position only
	| ; See also
	| : <code>[[#parsing|parsing]]</code>, <code>[[#imposing|imposing]]</code>, <code>[[#providing|providing]]</code>, <code>[[#reassigning|reassigning]]</code>, <code>[[#splicing|splicing]]</code>, <code>[[#discarding|discarding]]</code>
}}

; Brief
: ''Get rid of all the incoming parameters and create a new (empty) parameter stack''
; Syntax
: <syntaxhighlight lang="wikitext" inline>{{#invoke:params|new|pipe function name}}</syntaxhighlight>

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 <code>[[#entering_substack|entering_substack]]</code> directive. When in first position, its main purpose is that of extending the facilities offered by this module (e.g. <code>[[#mapping_by_replacing|mapping_by_replacing]]</code>, <code>[[#with_value_matching|with_value_matching]]</code>, 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 <code>new</code> modifier also facilitates debugging the module.

The newly created parameter stack can be populated via <code>[[#parsing|parsing]]</code>, <code>[[#imposing|imposing]]</code>, <code>[[#providing|providing]]</code>, or <code>[[#splicing|splicing]]</code>. The incoming parameters can always be retrieved back using the <code>[[#remembering|remembering]]</code>, <code>[[#pulling|pulling]]</code> and <code>[[#recalling|recalling]]</code> modifiers.

Examples:
* <syntaxhighlight lang="wikitext" inline>{{#invoke:params|new|imposing|1|foo|imposing|2|bar|mapping_by_replacing|^.|!%1|list_values}}</syntaxhighlight>
*: ↳ {{#invoke:params|new|imposing|1|foo|imposing|2|bar|mapping_by_replacing|^.|!%1|list_values}}

<div style="width: 100%; height: 1.5em;"></div>

== 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 [[:w:en:Special:PrefixIndex/Module:Params/|here]].

== Notes ==
<references />

== See also ==
* {{ml|TemplatePar}}
* {{ml|ParameterCount}}
* {{ml|Separated entries|main}}
* {{ml|Enumerate|main}}
* {{ml|Check for unknown parameters|check}}
* {{ml|Check for deprecated parameters|check}}
* {{ml|Check for clobbered parameters|check}}
* {{ml|Parameter validation}}
* {{ml|Expand wikitext|main}}
* {{ml|For loop|main}} and {{tl|For loop}}
* {{ml|For nowiki|template}} and {{tl|For nowiki}}
* {{ml|Template wrapper|wrap}}
* {{ml|ArrayList}}
* {{ml|TEMPLATENAME|main}}
* [[:w:en:Project:TemplateData|Project:TemplateData]]

<includeonly>{{Sandbox other||
<!-- Categories below this line; interwikis at Wikidata -->
}}</includeonly>