# Templates and Expressions

## Templates

A template is a string literal that contains zero or more substitutions, where a substitution is a script or expression embedded inside `{` and `}`.

The way that we interpret a template inside of an expression or script is by placing the template between characters, also called a template string:

```The result of 1 + 1 is \${1 + 1}.```

## Expressions

An expression is a value composed, recursively, of one or more values, joined by a combination of operators and parenthesized subexpressions.

``add(1, (i < 2 ? 1 : i)) + "x"``

Expressions may be used to construct Adaptive Script statements and may be also used directly by Adaptive Framework when a value needs to be computed.

Before moving onto Statements, it's worth noting that Expressions are quite capable of being used to compute some complicated logic by nesting expressions in a functional-looking manner. For example, take the following expression:

``add( if(1 < 2, 1, 2), 3 )``

This expression says to add 1 to 3 if 1 is less than 2, and to add 2 to 3 otherwise. A more readable way to express this logic is using the syntactic sugar provided by statements.

### Values

Values are the fundamental components of an expression. They can be List Values, Object Values, Scalar Literals, Evaluations, Parenthesized Expressions or Template Strings.

``````42
"abc"
true
null
[1, 2, 3]
{ "x": 42, "y": "abc" }
(1 + 1) + 3
`1 + 1 is {1 + 1}```````

### Factors

Factors join values with zero or more mathematical operators, optionally separated with parentheses. This includes multiplication `*`, division `/`, addition `+`, subtraction `-`, exponentiation `**`, modulus `%` and unary negation `-`.

``````42 * 2
42 / 2
37 - 5
2 ** 8
32 % 6
-14``````

### Comparisons

Comparisons join factors with zero or more relational operators, optionally separated with parentheses. This includes less than `<`, less than or equal to `<=`, greater than `>`, greater than or equal to `>=`, equal `==`, not equal `!=`, strict equal `===` and not strict equal `!==`. Comparisons result in a boolean result when evaluated.

``````42 < 2
2 >= 2
1 !== 0
a === b``````

### Logical Expressions

Logical Expressions are expressions joined together by the logical operators `&&` (and), `||` (or), and `!` (not).

``(a || b) && (c || !d)``

### Nullish Coalescing

A Nullish Coalescing expression joins two Logical Expressions using the `??` operator. The result is the first expression if it is not null or undefined, otherwise the result is the second expression.

``a ?? b``