Module:Params - Knowledge

21: 16514: 16278: 15978: 15689: 15309: 14852: 12871: 12567: 12329: 11641: 10920: 10633: 10361: 8931: 8293: 7803: 6859: 6710: 6530: 6290: 6055: 5788: 4737: 4427: 4127: 3741: 3550: 3238: 2022: 1864: 1706: 151: 5569: 80: 6077:, 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. The actions that modifiers do are done sequentially, in the same order chosen during the invocation of this module. Some modifiers, however, after signaling their presence to the modifiers that might follow, add their action to the queue of actions that will be done last (e.g. 52: 16451:. 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. 16155:. 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. 15862:. 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. 4943:). This will be an empty string for the group of incoming parameters that do not have a numerical suffix. A hyphen before the numerical suffix will be interpreted as a minus sign (and therefore the group id will be treated as a negative number). Numerical incoming parameters will be treated as if their prefix is an empty string (these can be captured using 13247:

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

15022:

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.

7299:

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

5002:

All unnamed arguments that follow the template name in the invocation of this module will appear as sequential parameters in each call. Named arguments will be passed verbatim. Both named and unnamed arguments passed to this function will be given precedence in case of collisions. Numerical argument

192:

Among the possibilities that the module offers there is that of performing a series of actions after novel arguments have been concatenated to templates' incoming parameters. As this makes it necessary to keep the argument slots clean from interference, instead of named arguments in order to specify

8869:

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

15046:

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 parameter's name and value if any of the latter has a numerical name

13611:

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 parameter's name and value if any of the latter has a numerical name

15502:

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 parameter's name and value if any of the latter has a numerical name

13593:

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.

10769:

If, and only if, the name of the parameter is numerical, it is possible to add a second argument to indicate how many contiguous parameters must be discarded as well. If the discarded parameters is part of the parameters' sequence one or more holes will be created. To avoid creating holes, see

8781:

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

61:. It has reached a mature form and is thought to be relatively bug-free and ready for use wherever appropriate. It is ready to mention on help pages and other Knowledge resources as an option for new users to learn. To reduce server load and bad output, it should be improved by 7813:

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

7049:

This modifier allows some internal variables to be set and later be used 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:

123:

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 (you can use

9464:

parameters available, the behavior will be the same as if the sum had been equal to the number of numerical parameters available, both when this is a positive value and when it is a negative value (with opposite results). When

10396:

This function optionally supports one argument to specify the sorting criterion. If this is omitted it is assumed that sequential values must be ordered alphabetically. Currently the only other possible criterion is

7330:

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.

250:

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

6338:

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.

2204:

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

731:

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

13597:

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

3957:

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 (

15482:

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 template name (see

15026:

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

9879:

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

9632:

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

7369:

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 defaults to

180: 4422:

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.

3545:

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.

2528:

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 (

16380:

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)

16080:

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)

8211:

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

6887:, 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. 611:

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

8993:

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

1948:

Prepend positive numerical arguments to the current parameters, or impose non-numerical or negative numerical arguments, then propagate everything to a custom parser function

8427:– which affects only the way parameters are shown – this modifier actually removes all non-sequential numerical parameters, albeit leaves non-numerical parameters intact. 2790:

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 (

1339:

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

15791:

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)

14957:

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)

1790:

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

8125:

Assign an empty string to all undefined numerical parameters between 1 or the lowest numerical parameter name provided and the maximum numerical parameter provided

12238: 1213:

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 arguments,

15475:

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

15414:

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)

1616:

modifier it is possible to impose numerical positive parameters instead of prepending them. For instance, the following code echoes all incoming parameters to

13196:, 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 6672:(IN FUNCTIONS ONLY, DOES NOT AFFECT MODIFIERS) When the time will come, all parameters will be dispatched sorted: first the numerical ones, then the rest in 4729: 12744: 12506: 11809: 11076: 3233:

template has been called. In most cases this will make no difference, however there are several situations where it will lead to nonsensical results.

138:

you can find helper templates that can be specifically used for testing the module's capabilities in flexible ways (see in particular the {{

1533: 12749: 12511: 11814: 11081: 2164:. With modifiers, however, it allows reaching parameters that would be unreachable without knowing their number in advance. For instance, writing 13532:

all parameter values, replacing their content with the expansion of a given template repeatedly called with one parameter (the parameter's value)

4433:

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

4411: 3556:

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

1870:

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

178:

to its documentation page, so that if breaking changes will be introduced in the future the template will be easily traceable without performing

16914: 9460:

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

3090:

All unnamed arguments following the template name will be placed after the key-value pair. Named arguments will be passed verbatim. A header (

9469:

parameters are present among the discarded parameters, all the remaining numerical parameters greater than zero will be shifted accordingly.

4122:

template has been called. Here this will make no difference, however there are several situations where it will lead to nonsensical results.

849:

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

12830: 12748:

function to find whether parameter names match against given patterns; therefore, unless a plain flag is set, please use the same syntax of

12510:

function to find whether parameter names match against given patterns; therefore, unless a plain flag is set, please use the same syntax of

11813:

function to find whether parameter names match against given patterns; therefore, unless a plain flag is set, please use the same syntax of

11080:

function to find whether parameter names match against given patterns; therefore, unless a plain flag is set, please use the same syntax of

6817:

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:

744:– this is known as the parameters' “sequence”. A parameter list that does not have a first parameter specified does not possess a sequence. 12829:

A typical use case of this function is that of purging all empty incoming parameters before calling another template, especially when this

5776: 16575:

To be precise, the order will not be strictly alphabetical, because this would imply that a template called with the following parameters

12117:|Precursor=truncus arteriosus|Supplies=|Image={{Heart diagram 250px}}|Name=Pulmonary artery|Image2=Alveoli diagram.png|Vein=pulmonary vein 6419:(IN FUNCTIONS ONLY, DOES NOT AFFECT MODIFIERS) Reduce the parameter list by discarding the subgroup of consecutive parameters that follow 4256:

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

16269:

This function can be particularly useful for sanitizing parameter names (e.g. collapsing several spaces into single spaces, changing the

15969:

This function can be particularly useful for sanitizing parameter names (e.g. collapsing several spaces into single spaces, changing the

7346:

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

120:, to which it offers the possibility to count, list, map and propagate the parameters received without knowing their number in advance. 14866:

keyword, the passed parameter names, and the number of additional parameters will not be trimmed of their leading and trailing spaces.

9838:

Remove zero or more parameters from any point of the list of numerical parameters, moving backwards and shifting everything accordingly

5637: 116:

module is designed to be adopted by those templates that want to have a deep control of their parameters. It is particularly useful to

16528:

keyword, the passed parameter names, and the number of additional arguments will not be trimmed of their leading and trailing spaces.

16292:

keyword, the passed parameter names, and the number of additional arguments will not be trimmed of their leading and trailing spaces.

15992:

keyword, the passed parameter names, and the number of additional arguments will not be trimmed of their leading and trailing spaces.

15703:

keyword, the passed parameter names, and the number of additional arguments will not be trimmed of their leading and trailing spaces.

15323:

keyword, the passed parameter names, and the number of additional arguments will not be trimmed of their leading and trailing spaces.

8877:

modifier. For instance, the following code prints the last unnamed parameter passed, but only if at least two parameters were passed:

7571:

Sometimes it might be necessary to make the values assigned depend on conditional expressions. For instance, the following imaginary

62: 13232:

would first discard 49 parameters and then trim the only value left, resulting in a more efficient code. As a general rule, placing

4963:– 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. 1701:

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

16925: 13438: 3892:

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

1692:

If the numerical parameters to replace are a limited number, as in the example above, a better alternative might be that of using

7743: 6804:) order. Attention must be paid to the fact that parameters whose name is a negative number will appear first. To avoid this the 502:

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

16910: 16813: 12299: 10124:

Reverse the order of all numerical parameters (not only sequential ones), making sure that the largest numerical parameter and

6199:(IN FUNCTIONS ONLY, DOES NOT AFFECT MODIFIERS) Reduce the parameter list to the subgroup of consecutive parameters that follow 13156:

Order affects also performance, and how many values will be trimmed of their leading and trailing spaces will depend on where

7585: 3355:

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

16898: 16820: 12306: 7403:

The string of text that will be placed after the iteration is over; it is never inserted if there are no parameters to show.

7388:

The string of text that will be placed before the iteration begins; it is never inserted if there are no parameters to show.

5794:

All arguments passed to this function except the template name will not be trimmed of their leading and trailing spaces. The

4133:

All arguments passed to this function except the template name will not be trimmed of their leading and trailing spaces. The

3244:

All arguments passed to this function except the template name will not be trimmed of their leading and trailing spaces. The

1712:

All arguments passed to this function except the template name will not be trimmed of their leading and trailing spaces. The

36: 4556:

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

12777:, the following code will get rid of all blank parameters (i.e. parameters whose values contain only zero or more spaces): 11633: 4725:&preloadparams%5b%5d=hello+world&preloadparams%5b%5d=%C3%A0%C3%A8%C3%AC%C3%B2%C3%B9&preloadparams%5b%5d=foo+bar 4743:

All arguments passed to this function except the magic word will not be trimmed of their leading and trailing spaces. The

3747:

All arguments passed to this function except the magic word will not be trimmed of their leading and trailing spaces. The

2028:

All arguments passed to this function except the magic word will not be trimmed of their leading and trailing spaces. The

16806: 15491:

If the call style flag or (if omitted) the template name is followed by one or more groups of three arguments led by the

15035:

If the call style flag or (if omitted) the function name is followed by one or more groups of three arguments led by the

13600:

If the call style flag or (if omitted) the template name is followed by one or more groups of three arguments led by the

12292: 5772: 2350:

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

16932: 16894: 16557: 15479:. The latter will be repeatedly called with at least one argument as first sequential argument: the parameter's value. 32: 11572:(or similar modules). For instance, the following examples creates a bullet list of all the parameters passed of type 3016:

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

12768:

is that the latter also requires that the lengths match (this happens only when the two strings are 100% identical).

12530:

is that the latter also requires that the lengths match (this happens only when the two strings are 100% identical).

11833:

is that the latter also requires that the lengths match (this happens only when the two strings are 100% identical).

11100:

is that the latter also requires that the lengths match (this happens only when the two strings are 100% identical).

7888:

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

6796:

Normally only sequential parameters are dispatched sorted, whereas non-sequential ones are dispatched randomly. The

5576: 2624:

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

46468: 16880: 11837: 11104: 7974:

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

58: 11869:

template, and this is being transcluded using the same parameters that we had imagined in the previous example at

9591:

Remove zero or more parameters from any point of the list of numerical parameters, shifting everything accordingly

4955:

in the callback template). Spaces between the prefix and the numerical suffix will be ignored (therefore writing

4935:

The custom template will be repeatedly called with the numerical id of the group (i.e. the numerical suffix) as

3667:

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

1013:

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

139: 13255:

makes this module behave like many Knowledge modules behave. For example, if we wanted to emulate {{

380: 46473: 12877:

The pattern arguments passed to this function will not be trimmed of their leading and trailing spaces. The

12573:

The pattern arguments passed to this function will not be trimmed of their leading and trailing spaces. The

12335:

The pattern arguments passed to this function will not be trimmed of their leading and trailing spaces. The

11647:

The pattern arguments passed to this function will not be trimmed of their leading and trailing spaces. The

10639:

The value imposed will not be trimmed of its leading and trailing spaces. The name of the parameter and the

15476: 13441:}} example template shows how to call any arbitrary template trimming all parameters beforehand. 9883:. If the second argument contains zero or a negative number its absolute value indicates what must be left 9636:. If the second argument contains zero or a negative number its absolute value indicates what must be left 4975:

or a negative number it will be decreased by one unit in order to leave the parameter zero undisturbed (so

4622: 3733: 2014: 12287:

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

46478: 16827: 15411: 14954: 13529: 12313: 9262:). If any of the two arguments contains a negative number its absolute value indicates what must be left 8865:

If the absolute value of the sum of the two arguments (left and right cut) is greater than the number of

6869:

modifier cannot be used with functions that propagate several parameters together in a single call, like

5558:

leaves only the parameters in which both the prefix and the numerical suffix are not empty strings). The

40: 13248:

parameters to retain their leading and trailing spaces (namely in non-sequential numerical parameters).

8969:

de facto gets rid of all sequential parameters, in most cases it is clearer and more idiomatic to write

16549: 12760:

or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between

12522:

or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between

11825:

or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between

11092:

or omitted. When omitted it is assumed that the target string is a Lua pattern. The difference between

9966:

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

805: 371:

We can also do more sophisticated things; for instance, by exploiting the possibility to set a header (

143: 24950:': The two directives ‘sequential’ and ‘non-sequential’ are in contradiction with each other' 24725:': The two directives ‘non-sequential’ and ‘sequential’ are in contradiction with each other' 8299:

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

1475: 324: 128: 5982:

The text returned by this function is not expanded further (currently this module does not offer an

5051:

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

16792: 13256: 5765: 4709: 2731: 5550:

Before calling this function you will likely want to reduce the list of parameters via one of the

16920: 16543: 16537: 11863: 11141: 11130: 9212:, arguments will be removed counting from the first and the last numerical arguments given (i.e. 6061:

The argument passed to this function will not be trimmed of its leading and trailing spaces. The

135: 87: 31577:', ‘discarding’: A range was provided, but the initial parameter name is not numerical' 16872: 16834: 5053: 976:

will offer a simpler solution, however there can be cases in which this becomes the way to go.

13160:

is placed. For instance, if a template were invoked with 50 parameters and its code contained

5640:}} you can find an example of how to use this function to list authors the same way 16905: 16785: 16462: 2242: 1166: 5548:

will affect what groups of parameters will be iterated, not what parameters will be grouped.

968:

it is possible to understand whether a page is being transcluded or not. For most cases the

16454:

This function can be particularly useful for sanitizing parameter names (e.g. changing the

8: 16864: 16465:}} to sanitize all parameter names confining them to their lower case version: 12974:

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

11845: 11112: 10161:

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

8418:

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

8208:

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

7971:

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

6793:

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

6512:

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

6272:

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

5996: 5898: 198: 6546:

modifier permanently marks a query, and no matter what transformations will follow (see

16778: 12320: 10402: 6801: 6673: 6647: 5644: 4876:

Call a custom template for each group of parameters that have the same numerical suffix

4714:

parser function would be called for each incoming parameter as first argument and with

2310:

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

16888: 16884: 16857: 16848: 16163: 5890: 4861: 3877: 3001: 117: 28: 16799: 16699:(with the dot in the middle between negative and positive numbers). To avoid this, 16288:

modifier name itself, the module name, the function name, the call style flag, the

15319:

modifier name itself, the module name, the function name, the call style flag, the

12981:

in different positions can generate different results. For instance, imagining our

11569: 8873:

In some cases it might be necessary to concatenate more than one invocation of the

5780: 7424:

All space characters in the directives arguments are discarded. Therefore writing

24781:': The ‘all_sorted’ directive is redundant when followed by ‘sequential’' 16841: 4853: 3869: 2993: 2886:

A giant owl-like creature; A large feline inhabiting Bodmin Moor; A sea serpent.

23821:-- Flush the parameters by calling a custom function for each value (after this 23363:-- keys from the table of options; non-numerical keys from the table of options 23356:-- Concatenate the numerical keys from the table of parameters to the numerical 11555:|Image={{Heart diagram 250px}}|Name=Pulmonary artery|Image2=Alveoli diagram.png 40699:-- Syntax: #invoke:params|invoke_for_each|module name|module function|[append 31038:', ‘inserting’: The amount must be a number greater than zero', 0) end 23370:-- will prevail over colliding non-numerical keys from the table of parameters 18194:-- Make an expanded copy of a table (shifting in both directions if necessary) 9409:

as arguments, as in the example above, the following parameters will be left:

46462: 37140:-- Syntax: #invoke:args|concat_and_invoke|module name|function name|[prepend 20628:-- Parse the arguments of the `mapping_*` and `renaming_*` class of modifiers 18738:-- Move a key from a table to another, but only if under a different name and 16159: 9672:

indicates that every numerical argument whose numerical name is greater than

5913:

For each parameter passed to the current template, expand all occurrences of

22342:-- Map parameters' values using a custom callback and a referenced table 19898:-- Maximum number of numerical parameters that can be filled, if missing (we 17626:-- Make a reduced copy of a table (shifting in both directions if necessary) 12893:

function name itself, however, will be trimmed of their surrounding spaces.

12589:

function name itself, however, will be trimmed of their surrounding spaces.

12351:

function name itself, however, will be trimmed of their surrounding spaces.

11663:

function name itself, however, will be trimmed of their surrounding spaces.

11179:

Anterior (frontal) view of the opened heart. (Pulmonary artery upper right.)

10643:

function name itself, however, will be trimmed of their surrounding spaces.

9208:, but instead of removing arguments from the extremities of the parameters' 8536:

If you want instead to remove sequential parameters and leave the rest, use

22764:-- Map parameters' names using a custom callback and a referenced table 15699:

modifier name itself, the parser function's name, the call style flag, the

7590: 7418:

The string of text that will be placed if there are no parameters to show.

163: 15: 19076:-- Callback styles for the `mapping_*` and `renaming_*` class of modifiers 18931:-- Special match keywords (functions and modifiers MUST avoid these names) 17351:-- Remove numerical elements from a table, shifting everything to the left 16513: 16277: 15977: 15688: 15308: 14851: 12870: 12566: 12328: 11640: 10919: 10632: 10360: 9919:

indicates that every numerical argument whose numerical name is less than

8999:

does not take effect until the final function is invoked. Writing instead

8930: 8292: 7802: 6858: 6709: 6529: 6289: 6065: