Editing Help:Substitution

{{for|detailed guidance on when to use substitution rather than transclusion|BattleTechWiki:Substitution}}
{{pp-protected|small=yes}}
{{BattleTechWiki how-to|H:SUBST}}

'''Substitution''' is a function whereby, when an editor saves a page, an item in the wikicode is permanently replaced with its current value. In particular, [[Help:Template|templates]] and [[Help:Magic words|magic words]] can be substituted, as an alternative to [[Help:Transclusion|transclusion]]. The difference is that when a template is substituted on a page, its appearance on that page will no longer be affected by later changes made to the template itself (as is the case in a transcluded template).

Substitution is done using the <code>subst:</code> modifier after the double opening braces. For example, to substitute the template {{tl|deletion}}, type <code><nowiki>{{subst:afd}}</nowiki></code>. You can check the resulting wikitext before saving by clicking "Show changes" (and see what the page will look like by clicking "Show preview").

[[w:Help:variable|Variable]]s and [[w:Help:parser function|parser function]]s can also be substituted, meaning that their current value will be recorded permanently on the page – they will not be re-evaluated whenever someone views the page.

==When to use substitution==
Generally speaking, templates are [[Help:Transclusion|transcluded]] rather than substituted, although there are some that are specifically designed to be substituted (and may not work if transcluded). Some reasons for substituting templates include:
*making the resulting page independent of future changes to the template
*enabling other automatic replacements to occur (for example, a template may contain four tildes, which will be replaced by the user's signature and timestamp provided the template is substituted)
*enabling the page to be copied to another project without copying the template
*making page rendering faster for the server
*making the correspondence between wikitext and rendered page easier to understand (the opposite may also apply)

Disadvantages of substitution may include:
*Updates to the template will not be reflected on the target page
*The resulting wikitext is longer and more complicated
*Other users cannot see that the text was produced using a template (and will not learn to use the template)
**Many templates add a hidden comment such as <code><nowiki><!-- Template:Foo --></nowiki></code> to the end of their output to mitigate this issue.

Time-dependent variables are substituted to make the rendered page independent of the time at which it is viewed. Substituting page-dependent variables makes the resulting wikitext independent of renaming of the page and of copying to another page.

For more detailed guidance, including lists of templates which should or should not be substituted, see [[BattleTechWiki:Substitution]].

==Syntax==
To substitute a template, use the same syntax as for [[Help:Transclusion|transclusion]], but include <code>subst:</code> after the opening double braces. For example, to substitute the template {{tl|deletion}}, type <code><nowiki>{{subst:deletion}}</nowiki></code>. Parameters can be included as in the case of transclusion, for example <code><nowiki>{{subst:deletion|Some article}}</nowiki></code>.

Pages not in the template namespace can also be substituted, e.g. <code><nowiki>{{subst:User:Deadfire/Drafts}}</nowiki></code>. To substitute the current content of a page in mainspace (i.e. one with no namespace prefix), two colons are required, as in <code><nowiki>{{subst::Page}}</nowiki></code>. If a substituted page or template does not exist, the entire expression (with braces and subst:) will remain unchanged in the wikitext and on the page.

Use the same syntax to substitute variables and parser functions, e.g. <code><nowiki>{{subst:PAGENAME}}</nowiki></code> or <code><nowiki>{{subst:#switch:{{NUMBEROFADMINS}}|1=Foo|1000=Bar|#default=Baz}}</nowiki></code>.

There may be whitespace between the opening braces and the "subst:". However it is recommended not to have any space or newlines immediately after the "subst:", as this will not work in every case.

==Technical implementation==
Substitution is part of the process performed on saving a page, and causes the wikitext saved as a result of the edit to differ from the text which the user actually entered in the edit window. Other replacements performed during this process include expansion of links using the [[w:Help:Pipe trick|pipe trick]], and replacement of multiple tildes with signatures and timestamps.

This means that substitution necessarily occurs before any actions performed at the time of page rendering (conversion of the stored wikitext to HTML). In particular, ''substitutions are done before transclusions''. So typing <code><nowiki>{{subst:Help:L{{in(tut)}}k}}</nowiki></code> will not do substitution, even though {{tl|in(tut)}} returns the text "in" and [[Help:Link]] exists. The transclusion of {{tl|in(tut)}} has not yet taken place when the substitution is attempted. However, replace <code><nowiki>{{in(tut)}}</nowiki></code> with <code><nowiki>{{subst:in(tut)}}</nowiki></code>, and both substitutions will be performed in the expected order.

Similarly:
*Typing <code><nowiki>{{subst:#if:{{x0}}|yes|no}}</nowiki></code> gives the wikitext "yes", even though {{tl|x0}} is an empty template, since the conditional parameter evaluates to the non-empty string "<nowiki>{{x0}}</nowiki>". However <code><nowiki>{{subst:#if:{{subst:x0}}|yes|no}}</nowiki></code> produces "no", since the inner substitution is performed first.
*Typing <code><nowiki>{{subst:#expr:2*{{{p|3}}}}}</nowiki></code> returns ''Expression error: unrecognised punctuation character "{"'', as the undefined parameter <nowiki>{{{p}}}</nowiki> has not been replaced by its default value (3) when the substitution occurs.


Clicking the "Show changes" button during editing shows the wikitext that will result ''after'' substitution and other immediate replacements are carried out. Clicking "Show preview" shows what the rendered page will look like after these replacements.

If a page substitutes itself (e.g. in the noinclude part of a template page) it substitutes the old version, as it was before the current edit.

If the expansion of a substituted template itself contains instances of the <code>subst:</code> syntax, then the substitutions are performed recursively. However ''substitution is not automatically recursive'' &ndash; if a substituted template contains ordinary transclusions or variables and parser functions which are not explicitly substituted, then these will not be substituted.

Note also that if instances of the <code>subst:</code> syntax appear in a template that is being ''transcluded'', then they will be rendered unchanged (as "<nowiki>{{subst:...}}</nowiki>"), since no substitution in wikitext is possible at the rendering stage. This feature can be exploited to control template behaviour (see [[#Making templates behave differently when transcluded or substituted|§&nbsp;Making templates behave differently when transcluded or substituted]]). However, it may be inconvenient when a template is designed to be possible to transclude as well as substitute &ndash; in this case <code>safesubst:</code> can be used instead of <code>subst:</code> (see [[#safesubst|§&nbsp;The safesubst: modifier]]).

==={{anchor|safesubst}}The safesubst: modifier===
{{shortcut|BTW:SAFESUBST}}
The <code>subst:</code> modifier can be replaced by the alternative modifier <code>safesubst:</code>. The two have the same behaviour, except when they are encountered during non-substituted expansion (transclusion or direct viewing) of a template. In such a situation, the code <code><nowiki>{{subst:...}}</nowiki></code> remains unparsed<!-- is this blank or as plaintext? -->, whereas the <code><nowiki>{{safesubst:...}}</nowiki></code> is treated as if no modifier were present &ndash; and so the subtemplate is transcluded or the variable or parser function evaluated.

Hence the <code>safesubst:</code> modifier is used in the code of templates which are designed to produce recursive substitution when substituted; but that are also intended to work when transcluded or simply to be viewed directly. Contrasted with using the <code>subst:</code> modifier, such templates would break in such cases of transclusion (and possibly on direct viewing).

For details on how to implement this (in particular, how to prevent the substitution from being performed as soon as the template code is saved), see [[#Recursive substitution|§&nbsp;Recursive substitution]].

==Recursive substitution==
As mentioned above, substitution is not automatically recursive. So if a substituted template has code containing transclusions of other templates and parser functions, that code will be copied "as is" into the resulting wikitext – the transcluded items will not themselves be substituted.

To make substitution work recursively, you must include the <code>subst:</code> syntax in the code of the calling template. However, you cannot do this by simply typing "subst:" within the template, as the substitution would then be performed as soon as the template is saved. There are two ways to work around this problem:
*Use <code><nowiki>subst:<noinclude/></nowiki></code> in place of plain <code>subst:</code>. The noinclude tag breaks up the substitution syntax when the template is saved, but will be stripped away when it is later substituted, allowing the inner substitution to take effect. Alternatively, a larger part of the template code can be wrapped in {{tag|onlyinclude}}. Then the wrapped code is ignored on the template page itself but not when it is transcluded.
*Make "subst:" the possible value of an expression containing a parameter, such as <code><nowiki>{{{subst-foo|subst:}}}</nowiki></code>, which will evaluate to "subst:" provided the parameter ''subst-foo'' is not set. This is a more flexible solution, as it allows the behaviour to be controlled via the parameter. For example, such a template might be called using <code><nowiki>{{subst:</nowiki>{{var|Templatename}}<nowiki>|subst-foo=|..}}</nowiki></code>, assigning the parameter an empty value and thus turning off the second level of substitution. If it is not planned to use the parameter, the parameter name is often chosen to be the empty string, giving <code><nowiki>{{{|subst:}}}</nowiki></code>.

'''To ensure that the template will still work as intended if it is transcluded instead of substituted, use <code>safesubst:</code> instead of <code>subst:</code>.''' This also applies if the template is also to be viewed directly, on its own page (although in this case, if the first of the above methods is used, plain subst: will still work, as the includeonly tags will cause the parser to ignore the subst: on direct viewing).

To see what a template will produce when fully expanded, without the need to explicitly substitute all subtemplates etc., the [[Special:ExpandTemplates]] tool can be used.

For more information, see the [[meta:Help:Recursive conversion of wikitext|Recursive conversion of wikitext]] help page at Meta. See also [[w:Help:Calculation#Substitution|Help:Calculation §&nbsp;Substitution]], {{tim|Example table with computations, with optional substitution}}, and the feature request at [[mediazilla:2777|substall]].

=== An example of recursion in action ===

This is an example using the actual [[Template:Like]], and a hypothetical Template:Foo. You are attempting to include the Template:Foo, and indirectly the Template:Like, on a third page through transclusion and substitution. Template:Like displays this symbol: {{Like}}

For example, let's say the Template:Foo contained the wikitext <code><nowiki>{{Like}}</nowiki></code>. If you then transclude it, using the wikitext <code><nowiki>{{Foo}}</nowiki></code>, this will transclude the Template:Like as you would expect. But if you use the wikitext <code><nowiki>{{subst:Foo}}</nowiki></code>, when you save it, you find the wikitext <code><nowiki>{{Like}}</nowiki></code> substituted rather than the wikitext of the page Template:Like. The substitution has not been recursive.

An example of recursion would be if the Template:Foo contained the wikitext <code><nowiki>{{{{{|safesubst:}}}Like}}</nowiki></code>. Now if you transclude it, using the wikitext <code><nowiki>{{Foo}}</nowiki></code>, this will transclude the Template:Like just as before. And if you save <code><nowiki>{{subst:Foo}}</nowiki></code> it will substitute the full actual wikitext of the Template:Like. You have therefore achieved recursive substitution.

=== Further examples ===
Note: {{Tlf|!}} substitutes to |.
{| class="wikitable"
|-
! rowspan="2" | Wikitext of Template:Foo
! rowspan="2" | When you view <nowiki>Template:Foo</nowiki>,<br />it looks like:
! colspan="2" | The result of <nowiki>{{Foo}}</nowiki><br />if included on this page
! colspan="2" | The result of <nowiki>{{subst:Foo}}</nowiki><br />if included on this page
|-
! saves as:
! renders as:
! saves as:
! renders as:
|-
|
 <nowiki>{{!}}

{{PAGENAME}}

{{#if: 1 | yes | no}}</nowiki>
|&#124;

Foo

yes
|
 <nowiki>{{Foo}}</nowiki>
|&#124;

Substitution

yes
|
 <nowiki>{{!}}

{{PAGENAME}}

{{#if: 1 | yes | no}}</nowiki>
|&#124;

Substitution

yes
|-
|
 <nowiki>{{{{{|subst:}}}!}}

{{{{{|subst:}}}PAGENAME}}

{{{{{|subst:}}}#if: 1 | yes | no}}</nowiki>
|<nowiki>{{subst:!}}</nowiki>

<nowiki>{{subst:PAGENAME}}</nowiki>

<nowiki>{{subst:#if: 1 | yes | no}}</nowiki>
|
 <nowiki>{{Foo}}</nowiki>
|<nowiki>{{subst:!}}</nowiki>

<nowiki>{{subst:PAGENAME}}</nowiki>

<nowiki>{{subst:#if: 1 | yes | no}}</nowiki>
|
 <nowiki>&#124;

Substitution

yes</nowiki>
|&#124;

Substitution

yes
|-
|
 <nowiki>{{{{{|safesubst:}}}!}}

{{{{{|safesubst:}}}PAGENAME}}

{{{{{|safesubst:}}}#if: 1 | yes | no}}</nowiki>
|&#124;

Foo

yes
|
 <nowiki>{{Foo}}</nowiki>
|&#124;

Substitution

yes
|
 <nowiki>&#124;

Substitution

yes</nowiki>
|&#124;

Substitution

yes
|}

== Making templates behave differently when transcluded or substituted ==

Sometimes it is desirable to make a template behave differently when substituted rather than when transcluded. A common trick for doing this is to use an expression like <code><nowiki>{{{{{subst|subst:}}}ns:0}}</nowiki></code>. This evaluates to the empty string if the template is being substituted (since the inner substitution takes effect, giving the prefix of [[BTW:namespace|namespace]] 0, which is empty), but to "<nowiki>{{subst:ns:0}}</nowiki>" if the template is being transcluded (since substitution cannot take place after transclusion).

A common application is in templates which are designed only to be substituted, to make them produce a warning if they are mistakenly transcluded instead. This is done in templates like {{tl|deletion}}, which are designed to produce a timestamp (e.g. for adding pages to dated categories), and will not be able to do this if transcluded.

A template, {{tl|issubst}}, has been created to simplify this. It returns "yes" if substitution is being performed, or the empty string otherwise. This can then be used as the parameter of a conditional parser function to make the template display a warning method if it is being transcluded, or to otherwise change the behaviour of a template depending on whether it is being transcluded or substituted.

==Documenting substitution==
Usage of a template through <code>subst:</code> does not automatically show up in page histories. Therefore, providing the line of wikitext containing "subst:" in the [[Help:edit summary|edit summary]] is especially useful.

Also, pages with a substituted template do not show up in backlinks, and the template does not appear in the list of transcluded templates on the edit page. The template could add pages to a category to track substitutions, but listing this category on a page may clutter the list of content-based categories the page is in. Also, comments outside noinclude tags are included in the wikitext. Thus a comment can be used to mention the template. Substitution of parameters does not work inside comments, but a workaround for this is to begin an intended comment with <code><nowiki><!<noinclude />--</nowiki></code> so that it turns into a comment once transcluded.

== Limitation ==
Substitution is not available inside {{tag|ref}} and {{tag|gallery}} tags. If you write {{tnull|subst:foo}}, it is not substituted nor transcluded, but remains as-is (it's a known bug, see [[https://phabricator.wikimedia.org/T4700 phab:T4700] and [https://gerrit.wikimedia.org/r/#/c/272916/ gerrit:272916] for current status).

However it is possible to bypass this limitation by using the magic word #tag. If you write, for instance, {{tnull|safesubst:<nowiki>#</nowiki>tag:ref|content of the reference}}, the ''content of the reference'' will be substituted and the {{tnull|<nowiki>#</nowiki>tag:ref<nowiki>|</nowiki>...}} will be replaced with {{tag|ref}}. A more concrete example:
If you write for instance {{tnull|safesubst:<nowiki>#</nowiki>tag:ref|...Title<nowiki>=</nowiki>ExampleTitle|archivedate<nowiki>=</nowiki><nowiki>{{subst:TODAY}}</nowiki>|Edition<nowiki>=</nowiki>Hardcover...}}
then the software will perform substitutions on the text within the last field and the {{tnull|<nowiki>#</nowiki>tag:ref<nowiki>|</nowiki>...}} will be replaced with {{tag|ref}}around the altered text, and the reference will be saved with the substitution; it'll be saved as "{{tnull||...Title<nowiki>=</nowiki>ExampleTitle|archivedate<nowiki>=</nowiki>29 January 2016|Edition<nowiki>=</nowiki>Hardcover|...}}" with {{tag|ref}} around it.
In other words, first the software will expand the templates and then place that expanded text within reference tags.
<!-- FAILS
Test: <nowiki>{{safesubst:#tag:ref|Title=ExampleTitle|archivedate={{subst:TODAY}}|Edition=Hardcover...}}</nowiki> becomes <ref archivedate="29 January 2016" Edition="Hardcover...">Title=ExampleTitle2</ref>
-->

== Templates for substitution ==
* {{tl|require subst}} can wrap templates which require subst:
* {{tl|issubst}} - Returns "yes" when substituted.
* {{tl|ifsubst}} - Similar to <nowiki>#if:</nowiki> [[H:MW|magic word]], judging from substituted or not.

==See also==

* [[meta:Help:Substitution]], a longer and more technical help page at Meta
* [[mw:Help:ExpandTemplates]]
* [[mw:Help:TemplateData]]

* Templates containing a call to itself with "subst:" and producing a similar call with updated info, either replacing or adding to the previous info:
** {{tim|last edit}} – example: <span class="plainlinks">[{{fullurl:Special:Contributions|limit=1&target={{urlencode:Example User}}}} last edit]</span>
** {{tim|page history}}

{{BattleTechWiki templates}}

[[Category:Help]]
[[Category:Template help]]