Sequences - Xref - Options - push

{data 'fruit'}["apple","pear"]{/data}
<p>A clean pass sees the store: {code clean}{fruit}{$fruit} {/fruit}{/code}</p>
{code}{sequence '7;8;9', push='nums'/}{/code}
<p>A plain pass pushed nums, and it survived: {pull:nums}{$sequence} {/pull:nums}</p>

{meta title='Nested Passes - {code} and {page}'}

<p>A nested pass is the engine run inside itself: the content of a <code>{code}</code>
pair, or the page a <code>{page}</code> tag names, is rendered as a complete PAD run
of its own, and what it produced lands in the surrounding page. The pass sees the request it
runs in - its variables, its stores - unless it asks for isolation.</p>

<h2>A pass and what it leaves behind</h2>

<p>A plain <code>{code}</code> shares everything. What the pass creates is still
there when it returns:</p>

{example 'fragments/page_1'}

<h2>The four isolation forms</h2>

<p>Three options decide how much of the request a pass sees, and how much of the pass the
request keeps. They differ on both sides of the boundary:</p>

<table border="1" cellpadding="8" cellspacing="0" style="border-collapse: collapse;">
  <tr><th>form</th><th>sees the outer state</th><th>what it created afterwards</th></tr>
  <tr><td><code>{code}</code></td>         <td>yes</td><td>still there</td></tr>
  <tr><td><code>{code reset}</code></td>   <td>no - a blank slate going in</td><td>still there</td></tr>
  <tr><td><code>{code clean}</code></td>   <td>yes</td><td>taken back out</td></tr>
  <tr><td><code>{code sandbox}</code></td> <td>no</td><td>taken back out</td></tr>
</table>

<p>&nbsp;</p>

{example 'fragments/page_2'}

<h2>Another page as a pass</h2>

<p><code>{page 'name'}</code> runs that page - its .php and its .pad - as a pass,
with the same isolation options. A <code>function</code> option runs the pass inside a PHP
function body, but it still starts from the caller's variables and what it sets comes back
out - a page whose .php half must not touch the caller's variables wants <code>clean</code>
or <code>sandbox</code>:</p>

{example 'fragments/page_3'}

<h2>Stores cross the boundary by the same rules</h2>

<p>The data, content, bool and sequence stores follow the isolation form. A
<code>clean</code> pass reads the request's stores; a <code>sandbox</code> or
<code>reset</code> pass starts without them. On the way out, only a plain pass's pushes
stay: each of the three isolated forms puts the request's stores back exactly as they
were, its own pushes included:</p>

{example 'fragments/page_4'}

<h2>Engine state is always put back</h2>

<p>Whatever the isolation form, the engine itself returns to where it was: a loop the pass
ran inside continues from the same row, and a request-lived counter such as
<code>{switch}</code>'s rotation is rolled back with the rest - a pass takes its
counting with it:</p>

{example 'fragments/page_5'}

<p>Both calls answer the first value: the rotation the pass advanced was restored when the
pass returned.</p>

{sequence '1..3', push='s'/}{pull:s reverse, 'abc'}{$s} {/pull:s}

{sequence '1..6', push='a'/}{sequence '1..3', push='b'/}{a:sum 'b'}{$sequence} {/a:sum}

{sequence '2;b;3', push='s'}{/sequence}{sequence add='s', rows=3}{$sequence} {/sequence}

{sequence '1..5', push='s'/}[{action s, action='nope'}{$sequence} {/action}]

{sequence '1..3', push='s'/}{Resume reverse}

{sequence '1..5', push='s'/}{resume 'reverse', 'x'}

{sequence '1..5', push='s'/}{resume 'typo', reverse}{pull:s}{$s} {/pull:s}

{sequence '1..5', push='s'/}{sequence '1..3', push='t'/}{resume pull='typo', reverse}{pull:t}{$t} {/pull:t}

{sequence 5, push='s'}{pull:s make, prime, build='fixed'}{$sequence} {/pull:s}

{sequence 5, push='x'}{resume:x add=1}

{sequence '2..4', push='st'}{sequence '1..6', slice='st'}{$sequence} {/sequence}

{sequence '1..3', push='p'/}
{echo '' | pull:p . pull:p}

{sequence '1..5', push='caseSeq'/}
{echo $caseSeq.3@sequences}