Expressions and operators

In the Puppet language, nearly everything is an expression, including literal values, references to variables, resource declarations, function calls, and more. In other words, almost all statements in the language resolve to a value and can be used anywhere that value would be expected.

Most of this page is about expressions that are constructed with operators. Operators take input values and operate on them (for example, mathematically) to result in some other value. Other kinds of expressions (for example, function calls) are described in more detail on other pages.

Some expressions have side effects and are used in Puppet primarily for their side effects, rather than for their result value. For example:

• Resource declaration: Adds a resource to the catalog.

• Variable assignment: Creates a variable and assigns it a value.

• Chaining statement: Forms a relationship between two or more resources.

Your code won't usually do anything with the value these expressions produce, but sometimes the value is useful for things like forming relationships to resources whose names can't be predicted until run time.

Expressions can be used almost everywhere, including:

• The operand of another expression.

• The condition of an if statement.

• The control expression of a case statement or selector statement.

• The assignment value of a variable.

• The argument or arguments of a function call.

• The title of a resource.

• An entry in an array

• A key or value of a hash.

Expressions cannot be used:

• Where a literal name of a class or defined type is expected (for example, in class or define statements).

• As the name of a variable (the name of the variable must be a literal name).

• Where a literal resource type or name of a resource type is expected (for example, in the type position of a resource declaration).

You can surround an expression by parentheses to control the order of evaluation in compound expressions (for example, 10+10/5 is 12, and (10+10)/5 is 4), or to make your code clearer.

For formal descriptions of expressions constructed with operators and other elements of the Puppet language, see the Puppet language specification.

Operator expressions

There are two kinds of operators:

• Infix operators, also called binary operators, appear between two operands:

  • $a = 1

  • 5 < 9

  • $operatingsystem != 'RedHat'

• Prefix operators, also called unary operators, appear immediately before a single operand:

  • *$interfaces

  • !$is_virtual

Operands in an expression can be any other expression — anything that resolves to a value of the expected data type is allowed. Each operator has its own rules, described in the sections below, for the data types of its operands.

When you create compound expressions by using other expressions as operands, use parentheses for clarity and readability:

(90 < 7) and ('RedHat' == 'RedHat') # resolves to false
(90 < 7) or ('RedHat' in ['Linux', 'RedHat']) # resolves to true

Order of operations

Compound expressions are evaluated in a standard order of operations. Expressions wrapped in parentheses are evaluated first, starting from the innermost expression:

# This example resolves to 30, not 23:
notice( (7+8)*2 )

For the sake of clarity, use parentheses in all but the simplest compound expressions.

The precedence of operators, from highest to lowest, is:

Precedence	Operator
1	! (unary: not)
2	- (unary: numeric negation)
3	* (unary: array splat)
4	in
5	=~ and !~ (regex or data type match or non-match)
6	*, /, % (multiplication, division, and modulo)
7	+ and - (addition/array concatenation and subtraction/array deletion)
8	<< and >> (left shift and right shift)
9	== and != (equal and not equal)
10	>=, <=, >, and < (greater or equal, less or equal, greater than, and less than)
11	and
12	or
13	= (assignment)