Zig Cheatsheet

const std = @import("std");

// @sqrt @sin @cos @exp @log @floor @addWithOverflow

// @as @errorFromInt @floatFromInt @ptrFromInt @intFromPtr @intFromEnum @intCast

// @call(modifier: std.lang.CallModifier, function: anytype, args: anytype) anytype
// const CallModifier = enum {
//   auto,
//   never_tail,
//   never_inline,
//   no_suspend,
//   always_tail,
//   always_inline,
//   compile_time,
// }

// @embedFile(comptime path: []const u8) *const [N:0]u8

// @compileError(comptime msg: []const u8) noreturn

// @compileLog(...) void
// This function prints the arguments passed to it at compile-time.

// @src() std.lang.SourceLocation

const a = [_]u8{1};
const b = [_]u8{2};
const c = a ++ b;               // {1, 2}

const d = [_]u8{1, 2, 3} ** 2;  // {1, 2, 3, 1, 2, 3}

if (condition) {

} else {

}
const discount = true;
const price: u8 = if (discount) 17 else 20; // if statements are also valid expressions!

const MyNumberError = error {
    TooBig,
    TooSmall,
};

fn canFail() MyNumberError!u8 {}

pub fn main() void {
    const n = canFail();
    if (n) |value| {
        // normal thing
    } else |err| switch (err) {
        // handle error
    }
}

// while (condition): (continue expression) {}

// for (items) |item| {}
// for (items, 0..) |item, index| {}
// for (items1, items2, items3) |item1, item2, item3|  {}

const players = 2;
switch (players) {
    1 => hello(),
    2 => work(),
    else => {
        alert();
    },
}

// {
//   defer runLater();
//   runNow();
// }

var text: MyError!Text = getText("foo.txt");

// catch error and replace it with a default value
const foo = canFail() catch 5;  // if fails, foo will be assigned 5

// calFail() catch |err| {
//   if (err == MyError.TooBig) {
//   }
// }

// {
//   errdefer cleanup();
//   try canFail();
// }

// try canFail(); => canFail() catch |err| return err;

const Ops = enum {inc, pow, dec};
// Since enum is really a set of numbers, we can assign them explicitly
const Stuff = enum(u8) {foo = 15}; // default value
const my_stuff: u8 = @intFromEnum(Stuff.foo); // get number from enum

const Character = struct {
    health: u8,
    gold: u32,
    experience: u32,
};

var foo: u8 = 5;
var bar: *u8 = &foo;

var foo: ?u32 = 10;             // it could be u32 or null
var bar = foo orelse 2;         // if foo == null; then bar = 2;
const bzz = bar.?;              // bar orelse unreachable;

var card = [4]u8{1, 2, 3, 4};
const hand: []u8 = card[0..3];  // slice to first 3 card

const Foo = union {
    small: u8,
    large: u64,
};

var foo: u8 = 5;
var p1: *u8 = &foo;
var p2: *const u8 = p1;         // mutable to immutable

var n1: u8 = 5;
var n2: u16 = n1;

var n3: f16 = 45.2;
var n4: f32 = n3;

const arr: [3]u8 = [3]u8{1, 2, 3};
const s: []const u8 = &arr;     // pointer to slice
const p: [*]const u8 = &arr;

var five: u8 = 5;
var a_five: *[1]u8 = &five;

var num: u8 = 6;
var maybe_num: ?u8 = num;
maybe_num = null;

// fn foo(comptime MyType: type) void {}
fn makeSequence(comptime T: type, comptime size: usize) [size]T {
    var sequence: [size]T = undefined;
    var i: usize = 0;

    while (i < size): (i += 1) {
        sequence[i] = @as(T, @intCast(i)) + 1;
    }

    return sequence;
}

// fn foo(thing: anytype) void {}

const Duck = struct {
    eggs: u8,
    loudness: u8,
    location_x: i32 = 0,
    location_y: i32 = 0,

    fn waddle(self: *Duck, x: i16, y: i16) void {
        self.location_x += x;
        self.location_y += y;
    }

    fn quack(self: Duck) void {
        if (self.loudness < 4) {
            print("\"Quack.\" ", .{});
        } else {
            print("\"QUACK!\" ", .{});
        }
    }
};

const RubberDuck = struct {
    in_bath: bool = false,
    location_x: i32 = 0,
    location_y: i32 = 0,

    fn waddle(self: *RubberDuck, x: i16, y: i16) void {
        self.location_x += x;
        self.location_y += y;
    }

    fn quack(self: RubberDuck) void {
        // Assigning an expression to '_' allows us to safely
        // "use" the value while also ignoring it.
        _ = self;
        print("\"Squeek!\" ", .{});
    }

    fn listen(self: RubberDuck, dev_talk: []const u8) void {
        // Listen to developer talk about programming problem.
        // Silently contemplate problem. Emit helpful sound.
        _ = dev_talk;
        self.quack();
    }
};

const Duct = struct {
    diameter: u32,
    length: u32,
    galvanized: bool,
    connection: ?*Duct = null,

    fn connect(self: *Duct, other: *Duct) !void {
        if (self.diameter == other.diameter) {
            self.connection = other;
        } else {
            return DuctError.UnmatchedDiameters;
        }
    }
};

const DuctError = error{UnmatchedDiameters};

pub fn main() void {
    // This is a real duck!
    const ducky1 = Duck{
        .eggs = 0,
        .loudness = 3,
    };

    // This is not a real duck, but it has quack() and waddle()
    // abilities, so it's still a "duck".
    const ducky2 = RubberDuck{
        .in_bath = false,
    };

    // This is not even remotely a duck.
    const ducky3 = Duct{
        .diameter = 17,
        .length = 165,
        .galvanized = true,
    };

    print("ducky1: {}, ", .{isADuck(ducky1)});
    print("ducky2: {}, ", .{isADuck(ducky2)});
    print("ducky3: {}\n", .{isADuck(ducky3)});
}

// This function has a single parameter which is inferred at
// compile time. It uses builtins @TypeOf() and @hasDecl() to
// perform duck typing ("if it walks like a duck and it quacks
// like a duck, then it must be a duck") to determine if the type
// is a "duck".
fn isADuck(possible_duck: anytype) bool {
    // We'll use @hasDecl() to determine if the type has
    // everything needed to be a "duck".
    //
    // In this example, 'has_increment' will be true if type Foo
    // has an increment() method:
    //
    //     const has_increment = @hasDecl(Foo, "increment");
    //
    // Please make sure MyType has both waddle() and quack()
    // methods:
    const MyType = @TypeOf(possible_duck);
    const walks_like_duck = @hasDecl(MyType, "waddle");
    const quacks_like_duck = @hasDecl(MyType, "quack");

    const is_duck = walks_like_duck and quacks_like_duck;

    if (is_duck) {
        // We also call the quack() method here to prove that Zig
        // allows us to perform duck actions on anything
        // sufficiently duck-like.
        //
        // Because all of the checking and inference is performed
        // at compile time, we still have complete type safety:
        // attempting to call the quack() method on a struct that
        // doesn't have it (like Duct) would result in a compile
        // error, not a runtime panic or crash!
        possible_duck.quack();
    }

    return is_duck;
}

inline for (.{u8, u16, u32, u64}) |T| { // these type only available at compile time
    print("{} ", .{@typeInfo(T).int.bits});
}

const foo = [3]*const [5]u8{"~{s}~", "<{s}>", "d{s}b"};
comptime var i = 0;

inline while (i < foo.len) : (i += 1) {
    print(foo[i] ++ "\n", .{foo[i]});
}

// function
// comptime llama();

// expression
// bar = comptime baz();

// block
// comptime {
//   ...
// }

// get a value from a block
// var llama = comptime bar: {
//   ...
// }

var future = io.async(someFunction, .{arg1, arg2}); // NOTE: the future may run immediately or on another thread
defer _ = future.cancel(io);                        // safety
const result = future.await(io);                    // NOTE: every future MUST be either .await or .cancel, leaks resources otherwise.
// both .await and .cancel BLOCK until the task finished and return the result.
// calling either one more than once is safe - subsquent calls just return a copy of the result!

var group: std.Io.Group = .init;
group.async(io, myTask, .{arg1});
group.async(io, myTask, .{arg2});
try group.await(io);            // blocks until all tasks finish

fn myTask(io: std.Io) u32 {
    io.sleep(...) catch |err| switch (err) {
        error.Canceled => return 0,
    };
    return 5;
}

const Race = std.Io.Select(union(enum) {
    fast: u32,
    slow: u32,
});
var buffer: [2]Race.Union = undefined;
var sel = Race.init(io, &buffer);

sel.async(.fast, fastFn, .{io});
sel.async(.slow, slowFn, .{io});

const winner = try sel.await(); // returns first completed
switch (winner) {
    .fast => |var| ...,
    .slow => |var| ...,
}
sel.cancelDiscard();            // cancel remaining, discard results

const old = io.swapCancelProtection(.blocked);
defer _ = io.swapCancelProtection(old);
// ... do some stuff safely ...  io.checkCancel() return error.Canceled if a cancel request is pending