test:zig

guide/language/integer-rules.zig

@@ -0,0 +1,54 @@
+const expect = @import("std").testing.expect;
+
+// Zig supports hex, octal and binary integer literals.
+
+const decimal_int: i32 = 98222;
+const hex_int: u8 = 0xff;
+const another_hex_int: u8 = 0xFF;
+const octal_int: u16 = 0o755;
+const binary_int: u8 = 0b11110000;
+
+// Underscores may also be placed between digits as a visual separator.
+
+const one_billion: u64 = 1_000_000_000;
+const binary_mask: u64 = 0b1_1111_1111;
+const permissions: u64 = 0o7_5_5;
+const big_address: u64 = 0xFF80_0000_0000_0000;
+
+// "Integer Widening" is allowed,
+// which means that integers of a type may coerce to an integer of another type,
+// providing that the new type can fit all of the values that the old type can.
+
+test "integer widening" {
+    const a: u8 = 250;
+    const b: u16 = a;
+    const c: u32 = b;
+    try expect(c == a);
+}
+
+// If you have a value stored in an integer that cannot coerce to the type that you want,
+// `@intCast` may be used to explicitly convert from one type to the other.
+// If the value given is out of the range of the destination type, this is detectable illegal behaviour.
+
+test "@intCast" {
+    const x: u64 = 200;
+    const y = @as(u8, @intCast(x));
+    try expect(@TypeOf(y) == u8);
+}
+
+// Integers, by default, are not allowed to overflow. Overflows are detectable illegal behaviour.
+// Sometimes, being able to overflow integers in a well-defined manner is a wanted behaviour.
+// For this use case, Zig provides overflow operators.
+// | Normal Operator | Wrapping Operator |
+// | `+` | `+%` |
+// | `-` | `-%` |
+// | `*` | `*%` |
+// | `+=` | `+=%` |
+// | `-=` | `-=%` |
+// | `*=` | `*=%` |
+
+test "well defined overflow" {
+    var a: u8 = 255;
+    a +%= 1;
+    try expect(a == 0);
+}