Hacker News Reader

I'm a C coder, a big fan of Rust and while I've heard of Zig before I still don't really get what it's going for. As far as I can tell it's Rust without the borrow checker and the mental overhead that goes with it. Maybe it's because I'm wearing my Rust glasses but some design choices seem a bit strange to me, for instance regarding Zig's unions (equivalent to Rust's enums or C's tagged unions):

https://ziglang.org/documentation/master/#union

    const Payload = union {
        Int: i64,
        Float: f64,
        Bool: bool,
    };

[...]

    var payload = Payload {.Int = 1234};
    // payload.Float = 12.34; // ERROR! field not active
    assert(payload.Int == 1234);
    // You can activate another field by assigning the entire union.
    payload = Payload {.Float = 12.34};
    assert(payload.Float == 12.34);

[...]

    // Unions can be given an enum tag type:
    const ComplexTypeTag = enum { Ok, NotOk }; 
    const ComplexType = union(ComplexTypeTag) {
        Ok: u8,
        NotOk: void,
    };

[...]

    const c = ComplexType { .Ok = 0 };
    assert(ComplexTypeTag(c) == ComplexTypeTag.Ok);

That's weird ergonomics IMO and quite a lot of typing. As far as I can tell there's no type inference? Also I'm not sure why const is used everywhere, even for things like type declarations, does Zig allow messing with types at runtime? That seems like a pretty high level language feature so it's quite interesting if it does.

Anyway, from what I see it's basically somewhat halfway between C and Rust, with some of the syntactic sugar of Rust but not the borrow checker and everything that goes along with it.

That being said the language is still very young and at this stage Rust was a bit of a mess as well, what with the numerous pointer types, green threads and the like... Maybe as they progress toward 1.0 they'll be able to expose a clearer picture of what they're doing.

View on HN

pub fn printValue(self: *OutStream, value: var) !void { const T = @typeOf(value); if (@isInteger(T)) { return self.printInt(T, value); } else if (@isFloat(T)) { return self.printFloat(T, value); } else { @compileError("Unable to print type '" ++ @typeName(T) ++ "'"); } }

const std = @import("std"); pub fn main() void { const ComplexType = union(enum) { Ok: u8, NotOk, }; var ct = ComplexType { .Ok = 123 }; std.debug.warn("{}\n", ct); ct = ComplexType.NotOk; std.debug.warn("{}\n", ct); }

pub fn ArrayList(comptime T: type) type { return struct { const Self = @This(); raw_items: []T, len: usize, allocator: *Allocator, // ... pub fn append(self: *Self, item: T) !void { const new_item_ptr = try self.addOne(); new_item_ptr.* = item; } pub fn addOne(self: *Self) !*T { const new_length = self.len + 1; try self.ensureCapacity(new_length); return self.addOneAssumeCapacity(); } // ... }; } test "std.ArrayList.basic" { var bytes: [1024]u8 = undefined; const allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator; var list = ArrayList(i32).init(allocator); try list.append(1); try list.append(2); try list.append(3); assert(list.len == 3); }

//kick any error up the call stack var buffer = try allocator.alloc(u8, 500); //in debug builds, assert that this will not fail //in release-fast failure will result in undefined //behavior. var buffer = allocator.alloc(u8, 500) catch unreachable;