if

if.zig

  1. // If expressions have three uses, corresponding to the three types:
  2. // * bool
  3. // * ?T
  4. // * anyerror!T
  6. const expect = @import("std").testing.expect;
  8. test "if expression" {
  9.     // If expressions are used instead of a ternary expression.
  10.     const a: u32 = 5;
  11.     const b: u32 = 4;
  12.     const result = if (a != b) 47 else 3089;
  13.     expect(result == 47);
  14. }
  16. test "if boolean" {
  17.     // If expressions test boolean conditions.
  18.     const a: u32 = 5;
  19.     const b: u32 = 4;
  20.     if (a != b) {
  21.         expect(true);
  22.     } else if (a == 9) {
  23.         unreachable;
  24.     } else {
  25.         unreachable;
  26.     }
  27. }
  29. test "if optional" {
  30.     // If expressions test for null.
  32.     const a: ?u32 = 0;
  33.     if (a) |value| {
  34.         expect(value == 0);
  35.     } else {
  36.         unreachable;
  37.     }
  39.     const b: ?u32 = null;
  40.     if (b) |value| {
  41.         unreachable;
  42.     } else {
  43.         expect(true);
  44.     }
  46.     // The else is not required.
  47.     if (a) |value| {
  48.         expect(value == 0);
  49.     }
  51.     // To test against null only, use the binary equality operator.
  52.     if (b == null) {
  53.         expect(true);
  54.     }
  56.     // Access the value by reference using a pointer capture.
  57.     var c: ?u32 = 3;
  58.     if (c) |*value| {
  59.         value.* = 2;
  60.     }
  62.     if (c) |value| {
  63.         expect(value == 2);
  64.     } else {
  65.         unreachable;
  66.     }
  67. }
  69. test "if error union" {
  70.     // If expressions test for errors.
  71.     // Note the |err| capture on the else.
  73.     const a: anyerror!u32 = 0;
  74.     if (a) |value| {
  75.         expect(value == 0);
  76.     } else |err| {
  77.         unreachable;
  78.     }
  80.     const b: anyerror!u32 = error.BadValue;
  81.     if (b) |value| {
  82.         unreachable;
  83.     } else |err| {
  84.         expect(err == error.BadValue);
  85.     }
  87.     // The else and |err| capture is strictly required.
  88.     if (a) |value| {
  89.         expect(value == 0);
  90.     } else |_| {}
  92.     // To check only the error value, use an empty block expression.
  93.     if (b) |_| {} else |err| {
  94.         expect(err == error.BadValue);
  95.     }
  97.     // Access the value by reference using a pointer capture.
  98.     var c: anyerror!u32 = 3;
  99.     if (c) |*value| {
  100.         value.* = 9;
  101.     } else |err| {
  102.         unreachable;
  103.     }
  105.     if (c) |value| {
  106.         expect(value == 9);
  107.     } else |err| {
  108.         unreachable;
  109.     }
  110. }
  112. test "if error union with optional" {
  113.     // If expressions test for errors before unwrapping optionals.
  114.     // The |optional_value| capture's type is ?u32.
  116.     const a: anyerror!?u32 = 0;
  117.     if (a) |optional_value| {
  118.         expect(optional_value.? == 0);
  119.     } else |err| {
  120.         unreachable;
  121.     }
  123.     const b: anyerror!?u32 = null;
  124.     if (b) |optional_value| {
  125.         expect(optional_value == null);
  126.     } else |err| {
  127.         unreachable;
  128.     }
  130.     const c: anyerror!?u32 = error.BadValue;
  131.     if (c) |optional_value| {
  132.         unreachable;
  133.     } else |err| {
  134.         expect(err == error.BadValue);
  135.     }
  137.     // Access the value by reference by using a pointer capture each time.
  138.     var d: anyerror!?u32 = 3;
  139.     if (d) |*optional_value| {
  140.         if (optional_value.*) |*value| {
  141.             value.* = 9;
  142.         }
  143.     } else |err| {
  144.         unreachable;
  145.     }
  147.     if (d) |optional_value| {
  148.         expect(optional_value.? == 9);
  149.     } else |err| {
  150.         unreachable;
  151.     }
  152. }
  1. $ zig test if.zig
  2. 1/5 test "if expression"... OK
  3. 2/5 test "if boolean"... OK
  4. 3/5 test "if optional"... OK
  5. 4/5 test "if error union"... OK
  6. 5/5 test "if error union with optional"... OK
  7. All 5 tests passed.

See also: