Module:Params

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

The module offers elegant shortcuts to non variadic templates as well. Outside templates it has virtually no applications; hence, if you plan to make experiments, make sure to do them from within a template, or you will not be able to see much.

In case your template uses this module, please add {{lua|Module:Params}} to its the documentation page, so that if breaking changes will be introduced in the future the template will be easily traceable.

General usage

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

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

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

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

and such template were called with the following arguments,

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

the following result would be produced:

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

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

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

thus yielding:

Beast of Bodmin

A large feline inhabiting Bodmin Moor

Morgawr

A sea serpent

Owlman

A giant owl-like creature

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

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

Thus, the previous code will produce:

Beast of Bodmin

A large feline inhabiting Bodmin Moor

Owlman

A giant owl-like creature

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

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

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

Functions

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

count

Function count

Num. of arguments	0
Often preceeded by	sequential
Not affected by	all_sorted
See also
{{#invoke:ParameterCount}}

Brief

Count the number of parameters wherewith a template was called

Syntax

{{#invoke:params|count}}

This function does not take arguments.

concat_and_call

Function concat_and_call

Num. of arguments	Ad libitum
Not affected by	all_sorted
See also
concat_and_invoke

Brief

Prepend numerical arguments to the current parameters or impose non-numerical arguments, then propagate everything to a custom template

Syntax

{{#invoke:params|concat_and_call|template name|[prepend 1]|[prepend 2]|[...]|[prepend n]|[named item 1=value 1]|[...]|[named item n=value n]|[...]}}

For example, if our {{Example template}} had the following code,

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

and were called with,

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

the following call to the {{Foo bar}} template would be performed:

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

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

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

concat_and_invoke

Function concat_and_invoke

Num. of arguments	Ad libitum
Not affected by	all_sorted
See also
concat_and_call

Brief

Prepend numerical arguments to the current parameters, or impose non-numerical arguments; then propagate everything to a custom module

Syntax

{{#invoke:params|concat_and_invoke|module name|function name|[prepend 1]|[prepend 2]|[...]|[prepend n]|[named item 1=value 1]|[...]|[named item n=value n]|[...]}}

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

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

value_of

Function value_of

Num. of arguments	1
Relevant runtime variables	h, f, n
Not affected by	all_sorted
See also
list_values

Brief

Get the value of a single parameter

Syntax

{{#invoke:params|value_of|parameter name}}

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

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

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

list

Function list

Num. of arguments	Ad libitum
Sortable	Yes
Relevant runtime variables	h, p, i, f, n
See also
list_values

Brief

List the template parameters (both their names and their values)

Syntax

{{#invoke:params|list}}

This function does not take arguments.

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

For example, the following code

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

will generate an output similar to the following.

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

list_values

Function list_values

Num. of arguments	Ad libitum
Sortable	Yes
Often preceeded by	sequential
Relevant runtime variables	h, i, f, n
See also
list, value_of, {{#invoke:separated entries}}

Brief

List the values of the incoming parameters

Syntax

{{#invoke:params|list_values}}

This function does not take arguments.

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

For example, the following code

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

will generate an output similar to the following.

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

call_for_each

Function call_for_each

Num. of arguments	Ad libitum
Sortable	Yes
Relevant runtime variables	h, i, f, n
See also
call_for_each_value, invoke_for_each, magic_for_each, {{#invoke:for loop}}, {{for loop}}

Brief

For each parameter passed to the caller template, call a custom template with at least two parameters (key and value)

Syntax

{{#invoke:params|call_for_each|template name|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...] }}

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

Calling a template for each key-value pair with

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

will be different than writing

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

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

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

invoke_for_each

Function invoke_for_each

Num. of arguments	Ad libitum
Sortable	Yes
Relevant runtime variables	h, i, f, n
See also
invoke_for_each_value, call_for_each, magic_for_each

Brief

For each parameter passed to the caller template, invoke a custom module function with at least two arguments (key and value)

Syntax

{{#invoke:params|invoke_for_each|module name|module function|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}

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

Invoking a module function for each key-value pair with

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

will be different than writing

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

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

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

magic_for_each

Function magic_for_each

Num. of arguments	Ad libitum
Sortable	Yes
Relevant runtime variables	h, i, f, n
See also
magic_for_each_value, call_for_each, invoke_for_each

Brief

For each parameter passed to the caller template, call a magic word with at least two arguments (key and value)

Syntax

{{#invoke:params|magic_for_each|parser function|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}

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

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

call_for_each_value

Function call_for_each_value

Num. of arguments	Ad libitum
Sortable	Yes
Often preceeded by	sequential
Relevant runtime variables	h, i, f, n
See also
call_for_each, invoke_for_each_value, magic_for_each_value, {{#invoke:for loop}}, {{for loop}}

Brief

For each parameter passed to the caller template, call a custom template with at least one parameter (i.e. the parameter's value)

Syntax

{{#invoke:params|call_for_each_value|template name|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}

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

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

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

This will be different than writing

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

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

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

invoke_for_each_value

Function invoke_for_each_value

Num. of arguments	Ad libitum
Sortable	Yes
Often preceeded by	sequential
Relevant runtime variables	h, i, f, n
See also
call_for_each_value, invoke_for_each, magic_for_each_value

Brief

For each parameter passed to the caller template, invoke a custom module function with at least one argument (i.e. the parameter's value)

Syntax

{{#invoke:params|invoke_for_each_value|module name|module function|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}

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

Invoking a module function for each value with

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

will be different than writing

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

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

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

magic_for_each_value

Function magic_for_each_value

Num. of arguments	Ad libitum
Sortable	Yes
Often preceeded by	sequential
Relevant runtime variables	h, i, f, n
See also
call_for_each_value, invoke_for_each_value, magic_for_each

Brief

For each parameter passed to the caller template, call a magic word with at least one argument (i.e. the parameter's value)

Syntax

{{#invoke:params|magic_for_each_value|parser function|[append 1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param n=value n]|[...]}}

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

For example, if a template had the following code,

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

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

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

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

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

for_each

Function for_each

Num. of arguments	1
Sortable	Yes
Relevant runtime variables	h, i, f, n
See also
list, list_values, {{#invoke:for nowiki}}, {{for nowiki}}

Brief

For each parameter passed to the caller template, expand all occurrences of $# and $@ within a given text as key and value respectively

Syntax

{{#invoke:params|for_each|wikitext}}

Example:

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

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

{{#invoke:params|sequential|concat_and_call|for nowiki|[separator]|<nowiki>{{{i}}} is {{urlencode:{{{1}}}|QUERY}}</nowiki>}}

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

Modifiers (piping functions)

The following are modifiers, i.e. functions that expect to be piped instead of returning to the caller. Each of them can be followed by either another modifier or a non-piping function.

sequential

Modifier sequential

Num. of arguments	0
Repeatable	No
Conflicts with	non-sequential, all_sorted
See also
non-sequential, all_sorted, squeezing

Brief

Reduce the parameter list to the subgroup of consecutive parameters that follow |1=

Syntax

{{#invoke:params|sequential|pipe function name}}

Example:

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

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

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

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

non-sequential

Modifier non-sequential

Num. of arguments	0
Repeatable	No
Conflicts with	sequential
See also
sequential, all_sorted

Brief

Reduce the parameter list by discarding the subgroup of consecutive parameters that follow |1=

Syntax

{{#invoke:params|non-sequential|pipe function name}}

Example:

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

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

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

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

all_sorted

Modifier all_sorted

Num. of arguments	0
Repeatable	No
Conflicts with	sequential
Has no effects on	count, value_of, concat_and_call, concat_and_invoke
See also
sequential

Brief

When the time will come, all parameters will be dispatched sorted: first the numerical ones, then the rest in alphabetical order

Syntax

{{#invoke:params|all_sorted|pipe function name}}

Example:

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

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

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

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

• count
• value_of
• concat_and_call
• concat_and_invoke

 Note: The all_sorted modifier cannot be used with functions that propagate several parameters together in a single call, like concat_and_call and concat_and_invoke, 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 invoked with.

setting

Modifier setting

Num. of arguments	2–6 (variable)
Repeatable	Yes
Memory slots
i	Iteration delimiter
p	Key-value delimiter
h	Header text
f	Footer text
n	Fallback text

Brief

Define glue strings

Syntax

{{#invoke:params|setting|directives|...|pipe function name}}

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

• {{#invoke:params|setting|i|{{!}}|list_values}}

  ↳ Set the value of iteration delimiter to |, then list all values

• {{#invoke:params|setting|ih|{{!}}|list_values}}

  ↳ Set the value of both header text and iteration delimiter to |, then list all values

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

  ↳ Set the value of both header text and iteration delimiter to |, set key-value pair delimiter to =, then list all parameters

• {{#invoke:params|setting|ih/p/n|{{!}}|{{=}}|No parameters were passed|list}}

  ↳ Set the value of both header text and iteration delimiter to |, set key-value pair delimiter to =, set fallback text to No parameters were passed, then list all parameters

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

The slots available are the following:

Slots	Variable	Description
i	Iteration delimiter	The string of text that will be placed between each iteration; it is never inserted unless there are two or more parameters to show.
p	Key-value pair delimiter	The string of text that will be placed between each parameter name and its value; it is never inserted by functions that only iterate between values, or by functions that pass the key-value pairs to external calls.
h	Header text	The string of text that will be placed before the iteration begins; it is inserted printed if there are no parameters to show.
f	Footer text	The string of text that will be placed after the iteration is over; it is never inserted if there are no parameters to show.
n	Fallback text	The string of text that will be placed if there are no parameters to show.

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

squeezing

Modifier squeezing

Num. of arguments	0
Repeatable	Yes
See also
sequential

Brief

Rearrange all parameters that have numerical names to form a compact sequence starting from 1, keeping the same order

Syntax

{{#invoke:params|squeezing|pipe function name}}

Example:

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

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

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

1. {{...|non-sequential|squeezing|...}}
2. {{...|squeezing|non-sequential|...}}
3. {{...|with_name_not_matching|^%-?%d+$|...}}

cutting

Modifier cutting

Num. of arguments	2
Repeatable	Yes
See also
sequential, squeezing

Brief

Remove zero or more parameters from the beginning and the end of the parameter list

Syntax

{{#invoke:params|cutting|left trim|right trim|pipe function name}}

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

Example:

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

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

In some cases it might be necessary to concatenate more than one invocation of the cutting function. For instance, notice the |cutting|1|0|cutting|-1|0 code in the following imaginary {{Foobar see also}} template in order to properly show the “and” conjunction and possibly an Oxford comma when more than two page names are provided:

{{Hatnote|{{{altphrase|Foobar see also}}}: {{#if:{{{1|}}}
		|[[{{trim|{{{1|}}}}}]]{{#invoke:params|sequential|squeezing|cutting|1|1|setting|ih|, |trimming_values|for_each|[[$@]]}}{{#invoke:params|sequential|squeezing|cutting|1|0|cutting|-1|0|setting|h|{{#if:{{{3|}}}|,}} and |trimming_values|for_each|[[$@]]}}
		|{{Error|{{tl|Foobar see also}} requires at least one page name}}
	}}
}}

 Suggestion: Although {{#invoke:params|cutting|-1|1|...}} de facto gets rid of all sequential parameters, it is clearer and more idiomatic to write {{#invoke:params|non-sequential|...}} to obtain the same effect. Writing {{#invoke:params|sequential|cutting|-1|1|...}} will leave zero arguments to show.

with_name_matching

Modifier with_name_matching

Num. of arguments	Ad libitum
Repeatable	Yes
See also
with_name_not_matching, with_value_matching, with_value_not_matching

Brief

Discard all parameters whose name does not match all the given patterns

Syntax

{{#invoke:params|with_name_matching|pattern 1|[plain flag 1]|[or]|[pattern 2]|[plain flag 2]|[or]|[...]|[pattern N]|[plain flag N]|pipe function name}}

Internally this modifier uses Lua's string.find() function to find whether parameter names match against given patterns; therefore, unless a target string is set to plain, please use the same syntax of Lua patterns. The plain flag can be either plain or omitted. When omitted it is assumed that the target string is a Lua pattern.

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

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

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

Test cases:

• List only the parameters whose names match against the ^Image pattern:

  ↳ {{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_matching|^Image|list}}

  ↳ |Image={{Heart diagram 250px}}|Image2=Alveoli diagram.png

• List the parameters whose names match against both patterns ^Image and %d+$:

  ↳ {{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_matching|^Image|with_name_matching|%d+$|list}}

  ↳ |Image2=Alveoli diagram.png

• List the parameters whose names match against either the ^Name or the ^Latin$ pattern:

  ↳ {{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_matching|^Name$|or|^Latin$|list}}

  ↳ |Latin=truncus pulmonalis, arteria pulmonalis|Name=Pulmonary artery

• List the parameters whose names match against either the ma plain string or the me$ pattern:

  ↳ {{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_matching|ma|plain|or|me$|list}}

  ↳ |Image={{Heart diagram 250px}}|Name=Pulmonary artery|Image2=Alveoli diagram.png

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

with_name_not_matching

Modifier with_name_not_matching

Num. of arguments	Ad libitum
Repeatable	Yes
See also
with_name_matching, with_value_matching, with_value_not_matching

Brief

Discard all parameters whose name matches all the given patterns

Syntax

{{#invoke:params|with_name_not_matching|pattern 1|[plain flag 1]|[and]|[pattern 2]|[plain flag 2]|[and]|[...]|[pattern N]|[plain flag N]|pipe function name}}

Internally this modifier uses Lua's string.find() function to find whether parameter names match against given patterns; therefore, unless a target string is set to plain, please use the same syntax of Lua patterns. The plain flag can be either plain or omitted. When omitted it is assumed that the target string is a Lua pattern.

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

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

• List only the parameters whose names do not match against the a pattern:

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

  ↳ |Precursor=truncus arteriosus|Supplies=|Vein=pulmonary vein

• List the parameters whose names do not match against the a plain string and do not match against the l plain string either:

  {{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_not_matching|a|plain|with_name_not_matching|l|plain|list}}

  ↳ |Precursor=truncus arteriosus|Vein=pulmonary vein

• List the parameters whose names do not match against either the a plain string or the n plain string:

  {{#invoke:params|setting|ih/p|{{!}}|{{=}}|with_name_not_matching|a|plain|or|n|plain|list}}

  ↳ |Precursor=truncus arteriosus|Supplies=|Image={{Heart diagram 250px}}|Name=Pulmonary artery|Image2=Alveoli diagram.png|Vein=pulmonary vein

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

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

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

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

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

with_value_matching

Modifier with_value_matching

Num. of arguments	Ad libitum
Repeatable	Yes
See also
with_name_matching, with_name_not_matching, with_value_not_matching

Brief

Discard all parameters whose value does not match all the given patterns

Syntax

{{#invoke:params|with_value_matching|pattern 1|[plain flag 1]|[or]|[pattern 2]|[plain flag 2]|[or]|[...]|[pattern N]|[plain flag N]|pipe function name}}

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

Internally this modifier uses Lua's string.find() function to find whether parameter names match against given patterns; therefore, unless a target string is set to plain, please use the same syntax of Lua patterns. The plain flag can be either plain or omitted. When omitted it is assumed that the target string is a Lua pattern.

Example:

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

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

with_value_not_matching

Modifier with_value_not_matching

Num. of arguments	Ad libitum
Repeatable	Yes
See also
with_name_matching, with_name_not_matching, with_value_matching

Brief

Discard all parameters whose value matches all the given patterns

Syntax

{{#invoke:params|with_value_not_matching|pattern 1|[plain flag 1]|[and]|[pattern 2]|[plain flag 2]|[and]|[...]|[pattern N]|[plain flag N]|pipe function name}}

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

Internally this modifier uses Lua's string.find() function to find whether parameter names match against given patterns; therefore, unless a target string is set to plain, please use the same syntax of Lua patterns. The plain flag can be either plain or omitted. When omitted it is assumed that the target string is a Lua pattern.

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

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

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

trimming_values

Modifier trimming_values

Num. of arguments	0
Repeatable	No

Brief

Remove leading and trailing spaces from values

Syntax

{{#invoke:params|trimming_values|pipe function name}}

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

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

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

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

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

no arguments would be shown.

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

Placing trimming_values together with non-sequential will result in an empty call with no effects, because non-sequential parameters are stripped of their leading and trailing spaces by default.

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

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

will be equivalent to writing,

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

whereas writing

{{trim|{{{1|}}}}}{{#invoke:params|sequential|squeezing|cutting|1|1|trimming_values|setting|ih|XXXX|list_values}}{{#invoke:params|sequential|squeezing|cutting|1|0|cutting|-1|0|trimming_values|setting|h|YYYY|value_of|1}}

will be equivalent to writing

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

See also

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

---

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


-- Special user-given keywords (functions and modifiers MUST avoid these names)
local mkeywords = {
--	['pattern'] = false,
	['plain'] = true,
	['or'] = 0
}


-- Set directives
local memoryslots = {
	i = 'itersep',
	p = 'pairsep',
	h = 'header',
	f = 'footer',
	n = 'ifngiven'
}


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


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


-- Prepare the context
local function context_init(frame, funcname, refpipe, refparams)
	local ctx = {}
	ctx.iterfunc = pairs
	ctx.pipe = copy_or_ref_table(frame.args, refpipe)
	ctx.frame = frame:getParent()
	ctx.params = copy_or_ref_table(ctx.frame.args, refparams)
	return funcname(ctx)
end


-- Move to the next action within the user-given list
local function context_iterate(ctx, n_forward)
	local nextfn
	if ctx.pipe[n_forward] ~= nil then
		nextfn = ctx.pipe[n_forward]:match'^%s*(.*%S)'
	end
	if nextfn == nil then
		error('No function name was given', 0)
	end
	if library[nextfn] == nil then
		error('The function "' .. nextfn .. '" does not exist', 0)
	end
	for idx = n_forward, 1, -1 do table.remove(ctx.pipe, idx) end
	return library[nextfn](ctx)
end


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


local function do_for_each_param(ctx, fn)
	local tbl = ctx.params
	if ctx.subset == 1 then
		for key, val in ipairs(tbl) do fn(key, val) end
		return
	end
	if ctx.subset == -1 then
		for key, val in ipairs(tbl) do tbl[key] = nil end
	end
	if ctx.dosort then
		local nums = {}
		local words = {}
		for key, val in pairs(tbl) do
			if type(key) == 'number' then
				nums[#nums + 1] = key
			else
				words[#words + 1] = key
			end

		end
		table.sort(nums)
		table.sort(words)
		for idx = 1, #nums do fn(nums[idx], tbl[nums[idx]]) end
		for idx = 1, #words do fn(words[idx], tbl[words[idx]]) end
		return
	end
	if ctx.subset ~= -1 then
		for key, val in ipairs(tbl) do
			fn(key, val)
			tbl[key] = nil
		end
	end
	for key, val in pairs(tbl) do fn(key, val) end
end


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



	--[[ Piped modifiers ]]--
	--------------------------------


-- See iface.sequential()
library.sequential = function(ctx)
	if ctx.subset == -1 then error('The two directives "non-sequential" and "sequential" are in contradiction with each other', 0) end
	if ctx.dosort then error('The "all_sorted" directive is redundant when followed by "sequential"', 0) end
	ctx.iterfunc = ipairs
	ctx.subset = 1
	return context_iterate(ctx, 1)
end


-- See iface['non-sequential']()
library['non-sequential'] = function(ctx)
	if ctx.subset == 1 then error('The two directives "sequential" and "non-sequential" are in contradiction with each other', 0) end
	ctx.iterfunc = pairs
	ctx.subset = -1
	return context_iterate(ctx, 1)
end


-- See iface.all_sorted()
library.all_sorted = function(ctx)
	if ctx.subset == 1 then error('The "all_sorted" directive is redundant after "sequential"', 0) end
	ctx.dosort = true
	return context_iterate(ctx, 1)
end


-- See iface.setting()
library.setting = function(ctx)
	local opts = ctx.pipe
	local cmd
	if opts[1] ~= nil then
		cmd = opts[1]:gsub('%s+', ''):gsub('/+', '/'):match'^/*(.*[^/])'
	end
	if cmd == nil then error('setting: No directive was given', 0) end
	local sep = string.byte('/')
	local argc = 2
	local dest = {}
	local vname
	local chr
	for idx = 1, #cmd do
		chr = cmd:byte(idx)
		if chr == sep then
			for key, val in ipairs(dest) do
				ctx[val] = opts[argc]
				dest[key] = nil
			end
			argc = argc + 1
		else
			vname = memoryslots[string.char(chr)]
			if vname == nil then error('setting: Unknown slot "' ..
				string.char(chr) .. '"', 0) end
			table.insert(dest, vname)
		end
	end
	for key, val in ipairs(dest) do ctx[val] = opts[argc] end
	return context_iterate(ctx, argc + 1)
end


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


-- See iface.cutting()
library.cutting = function(ctx)
	local lcut = tonumber(ctx.pipe[1])
	if lcut == nil then error('cutting: Left cut must be a number', 0) end
	local rcut = tonumber(ctx.pipe[2])
	if rcut == nil then error('cutting: Right cut must be a number', 0) end
	local tbl = ctx.params
	local len = #tbl
	if lcut < 0 then lcut = len + lcut end
	if rcut < 0 then rcut = len + rcut end
	local tot = lcut + rcut
	if tot > 0 then
		local cache = {}
		if tot >= len then
			for key, val in ipairs(tbl) do tbl[key] = nil end
			tot = len
		else
			for idx = len - rcut + 1, len, 1 do tbl[idx] = nil end
			for idx = 1, lcut, 1 do tbl[idx] = nil end
		end
		for key, val in pairs(tbl) do
			if type(key) == 'number' and key > 0 then
				if key > len then
					cache[key - tot] = val
				else
					cache[key - lcut] = val
				end
				tbl[key] = nil
			end
		end
		for key, val in pairs(cache) do tbl[key] = val end
	end
	return context_iterate(ctx, 3)
end


-- See iface.with_name_matching()
library.with_name_matching = function(ctx)
	local tbl = ctx.params
	local patterns = {}
	local argc = parse_match_args(ctx.pipe, patterns, 'with_name_matching')
	local nomatch
	for key in pairs(tbl) do
		nomatch = true
		for _, ptn in ipairs(patterns) do
			if string.find(key, ptn[1], 1, ptn[2]) then
				nomatch = false
				break
			end
		end
		if nomatch then tbl[key] = nil end
	end
	return context_iterate(ctx, argc)
end


-- See iface.with_name_not_matching()
library.with_name_not_matching = function(ctx)
	local tbl = ctx.params
	local patterns = {}
	local argc = parse_match_args(ctx.pipe, patterns,
		'with_name_not_matching')
	local yesmatch
	for key in pairs(tbl) do
		yesmatch = true
		for _, ptn in ipairs(patterns) do
			if not string.find(key, ptn[1], 1, ptn[2]) then
				yesmatch = false
				break
			end
		end
		if yesmatch then tbl[key] = nil end
	end
	return context_iterate(ctx, argc)
end


-- See iface.with_value_matching()
library.with_value_matching = function(ctx)
	local tbl = ctx.params
	local patterns = {}
	local argc = parse_match_args(ctx.pipe, patterns,
		'with_value_matching')
	local nomatch
	for key, val in pairs(tbl) do
		nomatch = true
		for _, ptn in ipairs(patterns) do
			if string.find(val, ptn[1], 1, ptn[2]) then
				nomatch = false
				break
			end
		end
		if nomatch then tbl[key] = nil end
	end
	return context_iterate(ctx, argc)
end


-- See iface.with_value_not_matching()
library.with_value_not_matching = function(ctx)
	local tbl = ctx.params
	local patterns = {}
	local argc = parse_match_args(ctx.pipe, patterns,
		'with_value_not_matching')
	local yesmatch
	for key, val in pairs(tbl) do
		yesmatch = true
		for _, ptn in ipairs(patterns) do
			if not string.find(val, ptn[1], 1, ptn[2]) then
				yesmatch = false
				break
			end
		end
		if yesmatch then tbl[key] = nil end
	end
	return context_iterate(ctx, argc)
end


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



	--[[ Piped functions ]]--
	------------------------------------


-- See iface.count()
library.count = function(ctx)
	local count = 0
	for _ in ctx.iterfunc(ctx.params) do count = count + 1 end
	if ctx.subset == -1 then count = count - #ctx.params end
	return count
end


-- See iface.concat_and_call()
library.concat_and_call = function(ctx)
	local opts = ctx.pipe
	local tname
	if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end
	if tname == nil then error('concat_and_call: No template name was provided', 0) end
	table.remove(opts, 1)
	return ctx.frame:expandTemplate{
		title = tname,
		args = concat_params(ctx)
	}
end


-- See iface.concat_and_invoke()
library.concat_and_invoke = function(ctx)
	local opts = ctx.pipe
	local mname
	local fname
	if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end
	if mname == nil then error('concat_and_invoke: No module name was provided', 0) end
	if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end
	if fname == nil then error('concat_and_invoke: No function name was provided', 0) end
	table.remove(opts, 2)
	table.remove(opts, 1)
	return require('Module:' .. mname)[fname](ctx.frame:newChild{
		title = 'Module:' .. fname,
		args = concat_params(ctx)
	})
end


-- See iface.value_of()
library.value_of = function(ctx)
	local opts = ctx.pipe
	local keystr
	if opts[1] ~= nil then keystr = opts[1]:match'^%s*(.*%S)' end
	if keystr == nil then error('value_of: No parameter name was provided', 0) end
	local keynum = tonumber(keystr)
	if (
		ctx.subset == -1 and keynum ~= nil and #ctx.params >= keynum
	) or (
		ctx.subset == 1 and (keynum == nil or #ctx.params < keynum)
	) then return (ctx.ifngiven or '') end
	local val = ctx.params[keynum or keystr]
	if val == nil then return (ctx.ifngiven or '') end
	return (ctx.header or '') .. val .. (ctx.footer or '')
end


-- See iface.list()
library.list = function(ctx)
	local pps = ctx.itersep or ''
	local kvs = ctx.pairsep or ''
	local sep = ctx.header or ''
	local las = ctx.footer or ''
	local foo = ctx.ifngiven or ''
	local ret = ''
	do_for_each_param(
		ctx,
		function(key, val)
			ret = ret .. sep .. key .. kvs .. val
			sep = pps
			foo = las
		end
	)
	return ret .. foo
end


-- See iface.list_values()
library.list_values = function(ctx)
	local pps = ctx.itersep or ''
	local sep = ctx.header or ''
	local las = ctx.footer or ''
	local foo = ctx.ifngiven or ''
	local ret = ''
	do_for_each_param(
		ctx,
		function(key, val)
			ret = ret .. sep .. val
			sep = pps
			foo = las
		end
	)
	return ret .. foo
end


-- See iface.for_each()
library.for_each = function(ctx)
	local pps = ctx.itersep or ''
	local las = ctx.footer or ''
	local sep = ctx.header or ''
	local foo = ctx.ifngiven or ''
	local txt = ctx.pipe[1] or ''
	local ret = ''
	do_for_each_param(
		ctx,
		function(key, val)
			ret = ret .. sep .. string.gsub(
				string.gsub(txt, '%$#', key),
				'%$@',
				val
			)
			sep = pps
			foo = las
		end
	)
	return ret .. foo
end


-- See iface.call_for_each()
library.call_for_each = function(ctx)

	local opts = ctx.pipe
	local tname

	if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end
	if tname == nil then error('call_for_each: No template name was provided', 0) end

	local ccs = ctx.itersep or ''
	local sep = ctx.header or ''
	local las = ctx.footer or ''
	local foo = ctx.ifngiven or ''
	local model = { title = tname, args = opts }
	local ret = ''

	table.insert(opts, 1, true)

	do_for_each_param(
		ctx,
		function(key, val)
			opts[1] = key
			opts[2] = val
			ret = ret .. sep .. ctx.frame:expandTemplate(model)
			sep = ccs
			foo = las
		end
	)

	return ret .. foo

end


-- See iface.invoke_for_each()
library.invoke_for_each = function(ctx)

	local opts = ctx.pipe
	local mname
	local fname

	if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end
	if mname == nil then error('invoke_for_each: No module name was provided', 0) end
	if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end
	if fname == nil then error('invoke_for_each: No function name was provided', 0) end

	local ccs = ctx.itersep or ''
	local sep = ctx.header or ''
	local las = ctx.footer or ''
	local foo = ctx.ifngiven or ''
	local model = { title = 'Module:' .. mname, args = opts }
	local mfunc = require(model.title)[fname]
	local ret = ''

	do_for_each_param(
		ctx,
		function(key, val)
			opts[1] = key
			opts[2] = val
			ret = ret .. sep .. mfunc(ctx.frame:newChild(model))
			sep = ccs
			foo = las
		end
	)

	return ret .. foo

end


-- See iface.magic_for_each()
library.magic_for_each = function(ctx)

	local opts = ctx.pipe
	local magic

	if opts[1] ~= nil then magic = opts[1]:match'^%s*(.*%S)' end
	if magic == nil then error('magic_for_each: No parser function was provided', 0) end

	local ccs = ctx.itersep or ''
	local sep = ctx.header or ''
	local las = ctx.footer or ''
	local foo = ctx.ifngiven or ''
	local ret = ''

	table.insert(opts, 1, true)

	do_for_each_param(
		ctx,
		function(key, val)
			opts[1] = key
			opts[2] = val
			ret = ret .. sep .. ctx.frame:callParserFunction(magic, opts)
			sep = ccs
			foo = las
		end
	)

	return ret .. foo

end


-- See iface.call_for_each_value()
library.call_for_each_value = function(ctx)

	local opts = ctx.pipe
	local tname

	if opts[1] ~= nil then tname = opts[1]:match'^%s*(.*%S)' end
	if tname == nil then error('call_for_each_value: No template name was provided', 0) end

	local ccs = ctx.itersep or ''
	local sep = ctx.header or ''
	local las = ctx.footer or ''
	local foo = ctx.ifngiven or ''
	local model = { title = tname, args = opts }
	local ret = ''

	do_for_each_param(
		ctx,
		function(key, val)
			opts[1] = val
			ret = ret .. sep .. ctx.frame:expandTemplate(model)
			sep = ccs
			foo = las
		end
	)

	return ret .. foo

end


-- See iface.invoke_for_each_value()
library.invoke_for_each_value = function(ctx)

	local opts = ctx.pipe
	local mname
	local fname

	if opts[1] ~= nil then mname = opts[1]:match'^%s*(.*%S)' end
	if mname == nil then error('invoke_for_each_value: No module name was provided', 0) end
	if opts[2] ~= nil then fname = opts[2]:match'^%s*(.*%S)' end
	if fname == nil then error('invoke_for_each_value: No function name was provided', 0) end

	local ccs = ctx.itersep or ''
	local sep = ctx.header or ''
	local las = ctx.footer or ''
	local foo = ctx.ifngiven or ''
	local model = { title = 'Module:' .. mname, args = opts }
	local mfunc = require(model.title)[fname]
	local ret = ''

	table.remove(opts, 1)

	do_for_each_param(
		ctx,
		function(key, val)
			opts[1] = val
			ret = ret .. sep .. mfunc(ctx.frame:newChild(model))
			sep = ccs
			foo = las
		end
	)

	return ret .. foo

end


-- See iface.magic_for_each_value()
library.magic_for_each_value = function(ctx)

	local opts = ctx.pipe
	local magic

	if opts[1] ~= nil then magic = opts[1]:match'^%s*(.*%S)' end
	if magic == nil then error('magic_for_each_value: No parser function was provided', 0) end

	local ccs = ctx.itersep or ''
	local sep = ctx.header or ''
	local las = ctx.footer or ''
	local foo = ctx.ifngiven or ''
	local ret = ''

	do_for_each_param(
		ctx,
		function(key, val)
			opts[1] = val
			ret = ret .. sep .. ctx.frame:callParserFunction(magic,
				opts)
			sep = ccs
			foo = las
		end
	)

	return ret .. foo

end


-- See iface.self()
library.self = function(ctx)
	return ctx.frame:getTitle()
end



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


-- The public table of functions
local iface = {}



	--[[ Non-piped modifiers ]]--
	------------------------------------


-- Syntax:  #invoke:params|sequential|function name
iface.sequential = function(frame)
	return context_init(frame, library.sequential, false, false)
end


-- Syntax:  #invoke:params|non-sequential|function name
iface['non-sequential'] = function(frame)
	return context_init(frame, library['non-sequential'], false, false)
end


-- Syntax:  #invoke:params|sort|function name
iface.all_sorted = function(frame)
	return context_init(frame, library.all_sorted, false, false)
end


-- Syntax:  #invoke:params|setting|directives|...|function name
iface.setting = function(frame)
	return context_init(frame, library.setting, false, false)
end


-- Syntax:  #invoke:params|squeezing|function name
iface.squeezing = function(frame)
	return context_init(frame, library.squeezing, false, false)
end


-- Syntax:  #invoke:params|cutting|left cut|right cut|function name
iface.cutting = function(frame)
	return context_init(frame, library.cutting, false, false)
end


-- Syntax:  #invoke:params|with_name_matching|pattern 1|[plain flag 1]|[or]
--            |[pattern 2]|[plain flag 2]|[or]|[...]|[pattern N]|[plain flag
--            N]|function name
iface.with_name_matching = function(frame)
	return context_init(frame, library.with_name_matching, false, false)
end


-- Syntax:  #invoke:params|with_name_not_matching|pattern 1|[plain flag 1]
--            |[and]|[pattern 2]|[plain flag 2]|[and]|[...]|[pattern N]|[plain
--            flag N]|function name
iface.with_name_not_matching = function(frame)
	return context_init(frame, library.with_name_not_matching, false,
		false)
end


-- Syntax:  #invoke:params|with_value_matching|pattern 1|[plain flag 1]|[or]
--            |[pattern 2]|[plain flag 2]|[or]|[...]|[pattern N]|[plain flag
--            N]|function name
iface.with_value_matching = function(frame)
	return context_init(frame, library.with_value_matching, false, false)
end


-- Syntax:  #invoke:params|with_value_not_matching|pattern 1|[plain flag 1]
--            |[and]|[pattern 2]|[plain flag 2]|[and]|[...]|[pattern N]|[plain
--            flag N]|function name
iface.with_value_not_matching = function(frame)
	return context_init(frame, library.with_value_not_matching, false,
		false)
end


-- Syntax:  #invoke:params|trimming_values|function name
iface.trimming_values = function(frame)
	return context_init(frame, library.trimming_values, false, false)
end



	--[[ Non-piped functions ]]--
	----------------------------------------


-- Syntax:  #invoke:params|count
iface.count = function(frame)
	return context_init(frame, library.count, true, true)
end


-- Syntax:  #invoke:args|concat_and_call|template name|[prepend 1]|[prepend 2]
--            |[...]|[item n]|[named item 1=value 1]|[...]|[named item n=value
--            n]|[...]
iface.concat_and_call = function(frame)
	return context_init(frame, library.concat_and_call, false, true)
end


-- Syntax:  #invoke:args|concat_and_invoke|module name|function name|[prepend
--            1]|[prepend 2]|[...]|[item n]|[named item 1=value 1]|[...]|[named
--            item n=value n]|[...]
iface.concat_and_invoke = function(frame)
	return context_init(frame, library.concat_and_invoke, false, true)
end


-- Syntax:  #invoke:params|value_of|parameter name
iface.value_of = function(frame)
	return context_init(frame, library.value_of, true, true)
end


-- Syntax:  #invoke:params|list
iface.list = function(frame)
	return context_init(frame, library.list, true, false)
end


-- Syntax:  #invoke:params|list_values
iface.list_values = function(frame)
	return context_init(frame, library.list_values, true, false)
end


-- Syntax:  #invoke:params|for_each|wikitext
iface.for_each = function(frame)
	return context_init(frame, library.for_each, true, false)
end


-- Syntax:  #invoke:params|call_for_each|template name|[append 1]|[append 2]
--            |[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
iface.call_for_each = function(frame)
	return context_init(frame, library.call_for_each, false, false)
end


-- Syntax:  #invoke:params|invoke_for_each|module name|module function|[append
--            1]|[append 2]|[...]|[append n]|[named param 1=value 1]|[...]
--            |[named param n=value n]|[...]
iface.invoke_for_each = function(frame)
	return context_init(frame, library.invoke_for_each, false, false)
end


-- Syntax:  #invoke:params|magic_for_each|parser function|[append 1]|[append 2]
--            |[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
iface.magic_for_each = function(frame)
	return context_init(frame, library.magic_for_each, false, false)
end


-- Syntax:  #invoke:params|call_for_each_value|template name|[append 1]|[append
--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
iface.call_for_each_value = function(frame)
	return context_init(frame, library.call_for_each_value, false, false)
end


-- Syntax:  #invoke:params|invoke_for_each_value|module name|[append 1]|[append
--            2]|[...]|[append n]|[named param 1=value 1]|[...]|[named param
--            n=value n]|[...]
iface.invoke_for_each_value = function(frame)
	return context_init(frame, library.invoke_for_each_value, false, false)
end


-- Syntax:  #invoke:params|magic_for_each_value|parser function|[append 1]
--            |[append 2]|[...]|[append n]|[named param 1=value 1]|[...]|[named
--            param n=value n]|[...]
iface.magic_for_each_value = function(frame)
	return context_init(frame, library.magic_for_each_value, false, false)
end


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


return iface