Documentation - The Zig Programming Language

Precedence §

Zig features partial operator precedence: not every operator has a defined precedence with every other operator. Mixing operators with ambiguous precedence is prohibited and parentheses are mandatory. Consequently, valid code is typically auto-descriptive; when reading and writing Zig code, there are very few precedence rules you'll need to remember.

operator_precedence.zig

const std = @import("std");

test "operator precedence" {
    // Arithmetic operators follow the conventional order of operations.
    {
        const a = 1 + 2 * 3 - 4 / 2;
        const b = 1 + (2 * 3) - (4 / 2);
        try std.testing.expectEqual(a, b);
    }

    // Remainder division is a special case. It still has a higher precedence than
    // addition and subtraction, but it has ambiguous precedence with itself and
    // other multiplication/division operators.
    {
        const a = 1 + 2 % 3;
        const b = 1 + (2 % 3);
        try std.testing.expectEqual(a, b);

        // `1 % 2 % 3`, `1 % 2 / 3`, etc. would be a compile error,
        // and parentheses would be required to disambiguate.
    }

    // Bitwise operators have ambiguous precedence with other bitwise operators.
    // However, non-shifting bitwise operators (&, |, ^) can be chained with themselves.
    {
        const a = 1 ^ 2 ^ 3;
        const b = (1 ^ 2) ^ 3;
        try std.testing.expectEqual(a, b);

        // `1 ^ 2 | 3`, `1 << 2 << 3`, etc. would be a compile error,
        // and parentheses would be required to disambiguate.

        // To mix bitwise operators, parentheses must be used.
        try std.testing.expectEqual(0x10101, (1 << 16) | (1 << 8) | 1);
    }

    // Comparison operators have lower precedence than both arithmetic and bitwise
    // operators. Comparisons cannot be chained.
    {
        const a = 1 | 4 <= 1 + 4;
        const b = (1 | 4) <= (1 + 4);
        try std.testing.expectEqual(a, b);

        // `1 == 2 >= 3`, etc. would be a compile error,
        // and parentheses would be required to disambiguate.
    }

    // Logical operators have lower precedence than comparison operators,
    // and may only be chained homogeneously (`and` with `and`, but not
    // with `or`, and vice versa).
    {
        const false_expr: bool = 7 < 2;
        const true_expr: bool = 1 + 1 == 2;

        const a = false_expr or false_expr or true_expr;
        const b = 7 < 2 or 7 < 2 or 1 + 1 == 2;
        const c = ((7 < 2) or (7 < 2)) or (1 + 1 == 2);
        try std.testing.expect(a and b and c);

        // `a or b and c`, etc. would be a compile error,
        // and parentheses would be required to disambiguate.
    }

    // `orelse` and `catch` may be chained with themselves, but not each other.
    {
        const some_null: ?u8 = null;

        const a = some_null orelse some_null orelse 2;
        const b = (some_null orelse some_null) orelse 2;
        try std.testing.expectEqual(a, b);

        // `a catch b orelse c`, etc. would be a compile error,
        // and parentheses would be required to disambiguate.

        // Prefix operators like `try` have higher precedence than `orelse`/`catch`.
        const c = try maybe() orelse 1;
        const d = (try maybe()) orelse 1;
        try std.testing.expectEqual(c, d);
    }
}

fn maybe() error{Fail}!?u8 {
    return null;
}

Shell

$ zig test operator_precedence.zig
1/1 operator_precedence.test.operator precedence...OK
All 1 tests passed.

ambiguous_precedence_orelse.zig

test "ambiguous precedence" {
    const x: ?bool = true;
    const y: bool = false;
    const z: bool = false;

    // The following expression is always considered ambiguous,
    // and, in this particular case, `(x orelse y) == z` would
    // produce a different result than `x orelse (y == z)`.
    _ = x orelse y == z;
}

Shell

$ zig build-obj ambiguous_precedence_orelse.zig
/home/ryan/Programming/zig/zig/doc/langref/ambiguous_precedence_orelse.zig:9:20: error: ambiguous operator precedence with operators ... orelse ... == ...; use parentheses to disambiguate
    _ = x orelse y == z;
                   ^~
/home/ryan/Programming/zig/zig/doc/langref/ambiguous_precedence_orelse.zig:9:11: note: previous ambiguous operator here
    _ = x orelse y == z;
          ^~~~~~
/home/ryan/Programming/zig/zig/doc/langref/ambiguous_precedence_orelse.zig:9:20: note: in zig 0.17.x, this was evaluated as (... orelse ...) == ...

There is a set of operators (prefix operators, suffix operators, etc) that have unambiguously higher precedence than all other operators. That set of operators has the following precedence table:

x() x[] x.y x.* x.?
a!b
x{}
!x -x -%x ~x &x ?x try
// lower precedence operators omitted

For the other operators, simplified operator precedence tables are provided below, each containing only the information that you'll need to know when reading/writing code that uses that particular category of operators. The operators that have ambiguous precedence or semantic errors with the relevant operators have been omitted, as have the operators with higher precedence (those shown above).

For arithmetic operators:

* / *% *| %
+ - +% -% +| -|
== != < > <= >=
and or

For bitwise operators:

<< <<| >> & ^ |
== != < > <= >=
and or

For null and error recovery operators:

catch orelse

For error set operators:

||

For array concatenation operators:

++

The full precedence rules can be found in the Grammar, which also includes an Operator Precedence Flowchart.