Expressions

An expression is the part of a tag that works out a value: 1 + 2, $price * $qty, $name | upper, $state in ('open', 'pending'). PAD's evaluator reads it - numbers, strings, fields, lists, operators, functions and pipes - and answers one value. This page goes through all of it; every example is live, its template beside what PAD made of it.

Where expressions stand

An expression is read wherever a tag takes a value: the parameter of {echo} and of {if} and {elseif}, the right side of {set $x = ...}, the value of {case} and its {when}s, the condition of {while} and {until}, a quoted option such as where='...', and an occurrence assignment %name = ... on a tag that loops:

{set $price = 12.5}
{set $qty   = 3}
<p>Total: {echo $price * $qty}</p>
{set $total = $price * $qty}
<p>{if $total gt 30}Free shipping{else}Shipping: 4.95{/if}</p>

{data 'stock'}
  [ {"item": "pen", "qty": 12}, {"item": "ink", "qty": 0}, {"item": "pad", "qty": 5} ]
{/data}
{stock where='$qty gt 0', %order = 20 - $qty}
  <p>{$item}: {$qty} in stock, order {$order}</p>
{/stock}

{set $n = 7}
<p>{$n} is {case $n % 2}{when0}even{when 1}odd{/case}</p>
{set $i = 1}
<p>{while $i le 20}{$i} {set $i = $i * 2}{/while}</p>

A field tag takes a pipe as it stands - {$name | trim} - and so does the closing tag of a pair, over everything the pair rendered. The pipes page has the opening and closing tag pipes in full:

{set $name = '  ada lovelace  '}
<p>{$name | trim | ucwords}</p>
{data 'langs'}["php", "sql", "pad"]{/data}
<p>{langs}{$langs} {/langs | upper}</p>

Values

Numbers

Whole numbers, decimals, a decimal that starts with its point (.5) and exponents (1e3, 2.5E-1). A minus before a number belongs to it. 0x followed by hexadecimal digits is not a number but a string of bytes: 0x41 is the letter A.

{echo 42}

{echo -7 + 2}

{echo 1.25 * 4}

{echo .5 + .25}

{echo 1e3 + 1}

{echo 2.5E-1 * 4}

{echo 0x41}

{echo 0x504144}

Strings

Text stands between single or double quotes, which mean the same: a $name inside double quotes stays text, it is not filled in as PHP would. A backslash starts an escape - \n, \r, \t, \\, \' and \"; any other letter after it is an error. The dot joins strings, and numbers with them:

{echo 'single quotes'}

{echo "double quotes"}

{echo 'it\'s'}

{echo "say \"hi\""}

{echo 'back\\slash'}

{echo 'one\ntwo' | php:nl2br}

{echo "a\tb" | php:strlen}

{echo 'Order ' . 42 . "!"}

Bare words

A word without quotes and without a sigil is looked up. An operator word - eq, and, not ... - is the operator; a PHP constant - TRUE, FALSE, NULL, PHP_EOL, M_PI - is its value; a word that names nothing stands for its own text.

{echo TRUE}

[{echo FALSE}] [{echo NULL}]

{echo PHP_INT_SIZE}

{echo M_PI | %.4f}

{echo hello}

{echo 'hello' eq hello}

Quote text. A bare word that names something PAD knows - a function, a tag, a property, a data set, a field - is that thing: count, name and first are properties, so {echo count} does not write the word count. Text in quotes is always text.

Fields, paths and indirection

$name reads a field: a variable the page's PHP set, one a {set} made, a field of the row a loop stands on. A dot walks into an array - $user.address.city, and $items.0 by position.

<?php

  $user  = [ 'name' => 'Ada', 'address' => [ 'city' => 'London', 'zip' => 'W1' ] ];
  $langs = [ 'PHP', 'SQL', 'PAD' ];

?>

<p>{echo $user.name . ' from ' . $user.address.city}</p>
<p>{echo $langs.0} and {echo $langs.2}</p>
<p>{$user.address.city | upper}, {$user.address.zip}</p>

$$name reads the field whose name another field holds - a path as well - the way {$$name} does as a tag. The name must be one of the application's fields; the engine's own pad... variables are never read this way.

<?php

  $lang     = 'nl';
  $hello_en = 'Hello';
  $hello_nl = 'Hallo';
  $hello_de = 'Guten Tag';

  $user     = [ 'name' => 'Ada', 'address' => [ 'city' => 'London' ] ];
  $show     = 'user.address.city';

?>

{set $key = 'hello_' . $lang}
<p>{echo $$key}, {echo $user.name}</p>
<p>{echo $$show}</p>

A field that holds a list is not a value: $items + 1 is an error. Walk the list with a loop, or hand it to a function with the array: prefix, below.

Options, properties and the placeholder

• #name - a parameter or option of the tag; in a {define} or a custom tag, the ones the tag was called with
• &name - a property of the tag, name@tag a property of the tag named - first@items, current@items, count@items (see properties)
• @ - the value piped into this part of the expression (see pipes below)

{define 'gross'}{parms net, vat=21}{echo #net * (1 + #vat / 100) | %.2f}{/define}
<p>{gross net=100} and {gross net=100, vat=9}</p>
{data 'steps'}["plan", "build", "ship"]{/data}
{steps}
  <p>{echo &current . ' of ' . &count}: {$steps}{echo last@steps ? ' - the last one' : ''}</p>
{/steps}

Lists

[ ] makes a list, its items separated by commas, with keys written key => value where wanted, mixed with plain items as PHP mixes them. A list is what {set} stores, what a loop walks and what a PHP function takes:

{set $book = [ 'title' => 'Minutes', 'pages' => 2 * 120 ]}
<p>{$book.title}: {$book.pages} pages</p>
{set $primes = [2, 3, 5, 7]}
<p>{primes}{$primes} {/primes}</p>
<p>{echo php:implode(' + ', [1, 2, 3]) . ' = ' . php:array_sum([1, 2, 3])}</p>

Type prefixes

A prefix says what a name is, so nothing else of that name can be meant: field:, array: (a list as a value), data: (a {data} set), constant:, php: (a PHP function), pad: and app: (a built-in or an application pipe function), function:, tag: and the others the prefix page lists:

{data 'colors'}["red", "green", "blue"]{/data}
{set $nums = [4, 8, 15]}
{set $title = 'Prefixes'}
<p>{echo constant:PHP_INT_SIZE}</p>
<p>{echo php:count(data:colors)}</p>
<p>{echo php:count(array:nums)} numbers, together {echo array:nums + 0}</p>
<p>{echo php:str_repeat('=', 5)}</p>
<p>{echo field:title | upper}</p>

Operators

The operators bind in this order, strongest first. Those of one row bind equally and are applied left to right - 10 - 2 + 3 is 11 - except **, which binds right to left. Round brackets group as usual.

The tests in, like, matches, range, between and contains read infix as well; they have a section of their own.

Arithmetic

As in PHP: / answers a decimal when it does not divide evenly, % works on whole numbers. A text that is a number counts as one - '5' + '5' is 10 - a text that is not, 'a' + 1, is an error, and so is a division by zero.

{echo 7 + 3}

{echo 7 - 3}

{echo 7 * 3}

{echo 7 / 2}

{echo 7 % 3}

{echo 2 ** 10}

{echo -(2 + 3)}

{echo 10 / 3}

Precedence

{echo 1 + 2 * 3}

{echo (1 + 2) * 3}

{echo 10 - 2 + 3}

{echo 12 / 2 * 3}

{echo 2 ** 3 ** 2}

{echo -3 ** 2}

{echo (-3) ** 2}

{echo 2 ** -1}

Joining text

The dot binds weaker than + and -: in 1 + 2 . 3 the sum comes first and is then joined with the 3, and in 1 . 5 + 5 the 1 is joined with 10. After a value a dot is the join, also right against it - 'a'.1 - and only where no value stands before it does a dot start a number.

{echo 'Order ' . 42}

{echo 'Total: ' . 3 * 4}

{echo 1 + 2 . 3}

{echo 1 . 5 + 5}

{echo (1 . 5) + 5}

{echo 'a'.1}

Comparing

Each comparison has a word and a symbol: eq or == (a single = too), ne, != or <>, and lt le gt ge or < <= > >=. The words read better in a template full of HTML. Numbers, and texts that are numbers, compare as numbers - '2' lt '10' holds; other texts compare character by character, case counting. PHP's === and !== are not there. A comparison answers 1 or nothing:

[{echo 3 eq 3}] [{echo 3 == '3'}] [{echo 3 = 4}]

[{echo 3 ne 4}] [{echo 3 != 4}] [{echo 3 <> 3}]

[{echo 2 lt 10}] [{echo 2 < 10}] [{echo 9 le 9}]

[{echo 5 gt 9}] [{echo 5 >= 5}]

[{echo '2' lt '10'}] [{echo 'apple' lt 'banana'}]

[{echo 'abc' eq 'ABC'}] [{echo 'abc' eq 0}]

Logic

and, or, xor and not, with &&, || and ! as their symbols. The word not binds weaker than the comparisons, so not $a eq $b denies the comparison; ! binds as tightly as a sign, so !$a eq $b compares !$a with $b. and and or stop at a left side that decides: $n gt 0 and 10 / $n gt 1 never divides by zero.

[{echo 1 and 0}] [{echo 1 && 1}]

[{echo 1 or 0}] [{echo 0 || 0}]

[{echo 1 xor 1}] [{echo 1 xor 0}]

[{echo not 1}] [{echo !0}]

[{echo not 1 eq 2}]

[{echo 1 eq 1 and not 2 eq 3}]

[{echo 2 gt 1 and 3 gt 2 or 0}]

A default: ??

a ?? b answers a unless it is empty - '', NULL, FALSE, an empty list - or a field that does not exist; then it answers b. A 0 is a value and stays. A field in front of ?? may be missing, also under the strict check: giving it a default is what the operator is for. The right side is worked out only when it is wanted. In a pipe it takes the piped value, and the default function does the same:

<?php

  $nickname = '';
  $count    = 0;
  $tags     = [];

?>

<p>{echo $nickname ?? 'no nickname'}</p>
<p>{echo $count ?? 'no count'}</p>
<p>{echo $surname ?? 'no surname'}</p>
<p>{echo $surname ?? $nickname ?? 'nothing at all'}</p>
<p>{$nickname | ?? 'anonymous'} - {$nickname | default('anonymous')}</p>

The inline ternary

cond ? then : else binds weakest of all: everything before the ? is the condition, and each branch runs to its : or to the end - 0 ? 'yes' : 'no' . '!' joins the '!' to the no. Only the branch chosen is worked out. Ternaries in a row read from the right, a ? b : c ? d : e being a ? b : (c ? d : e). The short form a ?: b answers a itself when it holds, and with nothing before the ? the piped value is the condition:

{echo 3 gt 1 ? 'many' : 'one'}

{echo 15 gt 10 ? (15 gt 20 ? 'L' : 'M') : 'S'}

{echo 15 gt 20 ? 'L' : 15 gt 10 ? 'M' : 'S'}

{echo '' ?: 'Untitled'}

{echo 'Draft' ?: 'Untitled'}

{echo 0 | ? 'some' : 'none'}

{echo 0 ? 'yes' : 'no' . '!'}

{data 'cart'}
  [ {"item": "pen", "qty": 1}, {"item": "book", "qty": 3}, {"item": "lamp", "qty": 0} ]
{/data}
{cart}
  <p>{$qty} {echo $qty eq 1 ? $item : $item . 's'}{echo $qty ? '' : ' - sold out'}</p>
{/cart}

Truth

Where a condition is wanted - {if}, where=, the ternary, and and or - a value is tested as PHP tests it: '', '0', 0, NULL, FALSE and an empty list are false, every other value is true - the texts '0.0', 'false' and a space among them.

{echo '' ? 'true' : 'false'}

{echo '0' ? 'true' : 'false'}

{echo 0 ? 'true' : 'false'}

{echo NULL ? 'true' : 'false'}

{echo [] ? 'true' : 'false'}

{echo '0.0' ? 'true' : 'false'}

{echo 'false' ? 'true' : 'false'}

{echo ' ' ? 'true' : 'false'}

{echo -1 ? 'true' : 'false'}

{echo [0] ? 'true' : 'false'}

The comparisons, the tests and the logic operators answer 1 for true and '' for false: written by {echo} a truth is a 1 or nothing at all, and truths add up as numbers.

[{echo 2 gt 1}] [{echo 1 gt 2}]

{echo (2 gt 1) + (3 gt 1) + (0 gt 1)}

{echo ('a' eq 'a') . '/' . ('a' eq 'b')}

{if 'x' eq 'x'}holds{/if}

Tests: in, like, matches, range, between, contains

A not between the value and the test denies the test, as SQL writes it: $s not in (...), not like, not matches, not range. The value is everything left of the test - 5 + 1 in (6, 7) tests 6.

[{echo 'a' in ('a', 'b')}] [{echo 'x' in ('a', 'b')}]

[{echo 3 in (1, 2, 3)}]

[{echo 'x' not in ('a', 'b')}]

[{echo 5 + 1 in (6, 7)}]

[{echo not 'a' in ('a', 'b')}]

like ignores case; _ stands for exactly one character:

[{echo 'Alice' like 'A%'}] [{echo 'alice' like 'A%'}]

[{echo 'Bob' like 'B_b'}] [{echo 'Barb' like 'B_b'}]

[{echo 'Bob' not like 'A%'}]

[{echo '50%' like '50\\%'}] [{echo '500' like '50\\%'}]

A backslash in a PAD string is an escape, so the backslash a regular expression needs is written twice: '/a\\.b/'. A {n} quantifier would open a tag - repeat the class, as below, or let the page's PHP hand the pattern over.

[{echo 'NL1234' matches '/^[A-Z][A-Z][0-9]+$/'}]

[{echo 'a.b' matches '/a\\.b/'}] [{echo 'axb' matches '/a\\.b/'}]

[{echo 'Hello' matches '/^h/i'}] [{echo 'Hello' matches '/^h/'}]

[{echo 'Hello' not matches '/^h/'}]

[{echo 20 range (20, 40)}] [{echo 40 range (20, 40)}] [{echo 41 range (20, 40)}]

[{echo 20 between (20, 40)}] [{echo 30 between (20, 40)}]

[{echo 'm' range ('a', 'z')}]

[{echo 50 not range (20, 40)}]

contains looks into a text, or into a list for an item equal to the one asked for:

[{echo 'banana' contains 'nan'}] [{echo 'banana' contains 'x'}]

[{echo 'banana' not contains 'x'}]

[{echo [1, 2, 3] contains 3}] [{echo ['a', 'b'] contains 'c'}]

Each test is a pipe function too, so it can stand after a pipe or be called, its value the first argument:

[{echo 'b' | in('a', 'b')}] [{echo in('b', 'a', 'b')}]

[{echo 'Alice' | like('A%')}] [{echo like('Alice', 'A%')}]

[{echo 7 | range(1, 9)}] [{echo range(7, 1, 9)}]

[{echo contains('banana', 'nan')}]

Together with and and or they make the conditions of the where option, which the data handling page covers with the other options:

{data 'orders'}
  [ {"nr": 1, "state": "paid",      "customer": "Ada"},
    {"nr": 2, "state": "cancelled", "customer": "Alan"},
    {"nr": 3, "state": "sent",      "customer": "Bob"},
    {"nr": 4, "state": "sent",      "customer": "Alice"} ]
{/data}
{orders where='$state not in ("cancelled", "refunded") and $customer like "A%"'}
  <p>{$nr}: {$customer}, {$state}</p>
{/orders}

Functions

The built-in pipe functions - upper, left, replace, date and the rest of the {functions} list - are used two ways. After a pipe they take the value on its left: $s | left(2). Written as a call with nothing piped in they take it as their first argument: left($s, 2), as PHP's own functions do - so they nest, and stand wherever a value can. The number of parameters is checked.

{echo 'abcdef' | left(2)}

{echo left('abcdef', 2)}

{echo 'Hello ' . upper('world')}

{echo upper(left('abcdef', 3))}

{echo 'a-b' | replace('-', upper(' and '))}

{if left('NL1234', 2) eq 'NL'}Dutch{/if}

{echo 'abcdef' | mid(2, 3)}

{echo 'abcdef' | right(2)}

{echo 'user@example.com' | after('@') | before('.')}

{echo 'Crème Brûlée & Co.' | slug}

{echo 1536 | bytes}

{echo 'a long sentence that goes on' | truncate(17)}

{echo 1234567 | abbreviate(1)}

{echo 22 | ordinal}

php:name calls a PHP function, and so does a plain name followed by ( that is no PAD function - ucfirst('word'); the setting $padPhpFunctions decides which PHP functions a template may call. A piped value goes in as the only argument - 'abc' | php:strrev - and into a call with arguments where @ stands: $n | php:number_format(@, 2).

{echo php:strlen('abc')}

{echo php:str_repeat('ab', 3)}

{echo 'abc' | php:strrev}

{echo php:number_format(1234567.891, 2)}

{echo 1234.5 | php:number_format(@, 2, ',', '.')}

{echo php:str_pad('7', 3, '0', STR_PAD_LEFT)}

{echo php:max(3, 9, 4)} {echo php:min([3, 9, 4])}

{echo ucfirst('word')} {echo 'word' | ucfirst}

A file in the application's _functions/ directory is a pipe function as well, the piped value its $value - this manual has _functions/stars.php. function: asks for whatever function kind the name is, app: for the application's own (see extending):

<p>{echo 'well done' | stars}</p>
<p>{echo 'well done' | function:stars}</p>
<p>{echo 'well done' | upper | stars | php:strlen}</p>

Pipes

A | hands the value on its left to what follows; the parts run left to right, each over what the one before answered:

{echo '  ada LOVELACE ' | trim | lower | ucwords}

{echo 'user@example.com' | after('@') | upper}

{echo 'pad' | upper | . '!' | php:str_repeat(@, 2)}

{echo 12 | * 1.21 | %.2f | . ' EUR'}

A part after a pipe is an expression of its own, and the piped value fills the place of the operand it lacks. An operator that opens the part takes it as its left side - | + 1, | . ' EUR', | ?? 'none'. A space between such an operator and its operand is required: | + 1, never | +1.

{echo 5 | + 1}

{echo 5 | * 2 | - 1}

{echo 50 | * 4 | / 8}

{echo 7 | % 3}

{echo 2 | ** 8}

{echo 'Hello' | . ' world'}

[{echo 10 | gt 5}]

[{echo 'abc' | eq 'abc'}]

[{echo 7 | in (1, 7)}]

[{echo 5 | * 2 gt 9}]

{echo '' | ?? 'empty'}

{echo 3 | - 1 . ' left'}

@ stands for the piped value wherever the part needs it, as often as it needs it:

{echo 4 | @ * @}

{echo 4 | @ + @ * 2}

{echo 'pad' | '"' . @ . '"'}

{echo 'pad' | @ . ' ' . upper(@)}

{echo 5 | @ gt 3 ? 'big' : 'small'}

A part that is a printf format - it starts with % and is one conversion - formats the value as PHP's sprintf does. A % that is no format is the remainder: | % 3.

{echo 3.14159 | %.2f}

{echo 5 | %05.2f}

{echo 42 | %05d}

{echo 42 | %+d}

{echo 255 | %x} {echo 255 | %X}

{echo 1234.5 | %e}

{echo 0.256 | * 100 | %.1f | . '%'}

A pipe inside round or square brackets belongs to that group: ($n | + 1) * 2 adds before it multiplies, upper($s | trim) trims the argument, and in a list or an argument list the pipe works on its own item. Outside brackets a pipe always ends the whole expression before it.

{echo (5 | + 1) * 2}

{echo upper('  pad  ' | trim)}

{echo php:max(1, 5 | + 1)}

{echo php:implode('-', [5 | + 1, 2 | * 10])}

{echo 'x' . ('pad' | upper) . 'x'}

A field tag with a pipe, {$x | upper}, writes its answer through the sanitize chain, like every field tag. {echo} writes it raw - the right one for HTML the page made itself, the wrong one for what a visitor typed:

{set $html = '<i>pad</i>'}
<p>{$html | upper}</p>
<p>{echo $html | upper}</p>

Dates

date(format, modifier) reads a Unix timestamp, a date in text or a date object the page's PHP made; the modifier is what PHP's strtotime reads, such as '+1 week'. Written as a call it keeps PHP's order, the format first: date('Y', $created). Dates written YYYY-MM-DD compare correctly as plain text. now is the current time, and the locale page has localDate:

{echo '2026-10-18' | date('d M Y')}

{echo '2026-10-18' | date('l')}

{echo '2026-10-18' | date('Y-m-d', '+1 week')}

{echo '2026-10-18 14:30' | date('H:i')}

{echo date('Y', 1000000000)}

[{echo '2026-10-18' gt '2026-01-01'}]

Lists meeting operators

An arithmetic operator or a comparison that meets a list works with the sum of its numbers. A list holding more than numbers, or met by the dot, is an error. A field that holds a list is handed over with the array: prefix:

{echo [1, 2, 3] + 1}

{echo [1, 2] + [3, 4]}

{echo [1, 2] * 2}

[{echo [1, 2, 3] eq 6}]

{echo php:count([1, 2, 3])}

{echo [] ?? 'an empty list'}

{set $scores = [7, 9, 4, 10]}
<p>Sum {echo array:scores + 0}, count {echo php:count(array:scores)}</p>
<p>Average {echo (array:scores + 0) / php:count(array:scores)}</p>
<p>Best {echo php:max(array:scores)}, worst {echo php:min(array:scores)}</p>
<p>{echo php:implode(', ', array:scores)}</p>

Numbers at the edges

What is not a number - a NAN such as php:sqrt(-1) - is empty. % works on whole numbers, as PHP's does; php:fmod keeps the fraction. Decimals are written with PHP's precision, so 0.1 + 0.2 comes out as 0.3:

[{echo php:sqrt(-1)}]

{echo php:sqrt(-1) ?? 'not a number'}

{echo php:intdiv(7, 2)} {echo 7 % 2}

{echo 7.5 % 2} {echo php:fmod(7.5, 2)}

{echo 0.1 + 0.2}

Values are text

An expression's answer is a value, and a value never becomes template code: a field that holds braces - from a database, a form, a file - is written as the text it is. To run it as PAD on purpose, say so where it is used, with the code pipe (or sandbox, which runs it in an isolated pass):

<?php

  // Text that came from somewhere else - a database, a form, a file.

  $snippet = '{echo 6 * 7}';

?>

<p>{$snippet}</p>
<p>{echo $snippet . ' is text'}</p>
<p>{echo $snippet | code}</p>

When an expression is wrong

Under the strict syntax check - $padCheckSyntax, on by default - a mistake in an expression is an error that names the fault and its place, and the page answers with the error report instead of guessing. The report shows the template's file, line and column with the lines around it (see errors in the template). What some mistakes are told:

The lenient walk

With $padCheckSyntax = FALSE in _config/config.php nothing is reported and the evaluator answers what it can: a text that is no number counts as 0 ('a' + 1 is 1), a missing field is empty ($nope + 1 is 1), an unknown escape loses its backslash, and an expression that cannot be worked out at all - a bracket never closed, a division by zero, a PHP function refusing its arguments - answers nothing. That suits old templates; a new one is better off with the check, which finds the typo the lenient walk hides.

See also

• Conditions and branching - {if}, {case} and the ternary in templates
• Pipes - pipes on tags, opening and closing
• Properties - first@items and the others
• Prefix - the type prefixes
• Field sigils - {!name}, {^name} and the rest
• Level and occurrence variables - $ and %