Operators

Name	Syntax	Associativity	Precedence
Attribute selection	attrset `.` attrpath [ `or` expr ]	none	1
Function application	func expr	left	2
Arithmetic negation	`-` number	none	3
Has attribute	attrset `?` attrpath	none	4
List concatenation	list `++` list	right	5
Multiplication	number `` number*	left	6
Division	number `/` number	left	6
Subtraction	number `-` number	left	7
Addition	number `+` number	left	7
String concatenation	string `+` string	left	7
Path concatenation	path `+` path	left	7
Path and string concatenation	path `+` string	left	7
String and path concatenation	string `+` path	left	7
Logical negation (`NOT`)	`!` bool	none	8
Update	attrset `//` attrset	right	9
Less than	expr `<` expr	none	10
Less than or equal to	expr `<=` expr	none	10
Greater than	expr `>` expr	none	10
Greater than or equal to	expr `>=` expr	none	10
Equality	expr `==` expr	none	11
Inequality	expr `!=` expr	none	11
Logical conjunction (`AND`)	bool `&&` bool	left	12
Logical disjunction (`OR`)	bool `\|\|` bool	left	13
Logical implication	bool `->` bool	none	14

Attribute selection

attrset . attrpath [ or expr ]

Select the attribute denoted by attribute path attrpath from attribute set attrset. If the attribute doesn’t exist, return the expr after or if provided, otherwise abort evaluation.

An attribute path is a dot-separated list of attribute names.

attrpath = name [ . name ]...

Has attribute

attrset ? attrpath

Test whether attribute set attrset contains the attribute denoted by attrpath. The result is a Boolean value.

Arithmetic

Numbers are type-compatible: Pure integer operations will always return integers, whereas any operation involving at least one floating point number return a floating point number.

String concatenation

string + string

Concatenate two strings and merge their string contexts.

Path concatenation

path + path

Concatenate two paths. The result is a path.

Path and string concatenation

path + string

Concatenate path with string. The result is a path.

Note

The string must not have a string context that refers to a store path.

String and path concatenation

string + path

Concatenate string with path. The result is a string.

Important

The file or directory at path must exist and is copied to the store. The path appears in the result as the corresponding store path.

Update

attrset1 // attrset2

Update attribute set attrset1 with names and values from attrset2.

The returned attribute set will have of all the attributes in attrset1 and attrset2. If an attribute name is present in both, the attribute value from the latter is taken.

Comparison

Comparison is

arithmetic for numbers
lexicographic for strings and paths
item-wise lexicographic for lists: elements at the same index in both lists are compared according to their type and skipped if they are equal.

All comparison operators are implemented in terms of <, and the following equivalencies hold:

comparison	implementation
a `<=` b	`! (` b `<` a `)`
a `>` b	b `<` a
a `>=` b	`! (` a `<` b `)`

Equality

Attribute sets and lists are compared recursively, and therefore are fully evaluated.
Comparison of functions always returns false.
Numbers are type-compatible, see arithmetic operators.
Floating point numbers only differ up to a limited precision.

Logical implication

Equivalent to !b1 || b2.

Nix Reference Manual