01:57 <daurnimator> donpdonp: btw, you can just use `i32(-1)` rather than `@intCast(i32, -1)`.

01:59 <daurnimator> the former is fully defined and safety checked; the latter is potentially unsafe.

02:05 <daurnimator> So I'm trying to figure out how to translate some complex structure definitions/usage to zig

02:06 <daurnimator> and I think there's a few missing language features

02:07 <daurnimator> lets start with: usize bytes. If the lowest bit is even, then consider it to be an aligned pointer. otherwise cast the top bit to a boolean.

02:08 <daurnimator> Is this the right starting point? union { Ptr: align(32) *c_void, Bool: bool }

02:09 <daurnimator> but then how can I tell zig how to pick which bit the boolean is?

02:09 <daurnimator> or how can I tell it that the bottom bit is the "tag" bit?

02:10 <daurnimator> s/align(32)/align(2)/

03:53 <Marumoto> does linkSystemLibrary look in /usr/lib?

04:38 <daurnimator> Marumoto: if I recall correctly, not by default.

07:57 <Hejsil> daurnimator, We don't have a way to specify the location of the union tag, so I don't think a union is the right choice for your problem

07:58 <Hejsil> I think a struct with a usize field and methods that does the conversion is the best you can do

07:59 <Hejsil> struct {f:usize, fn toBool(me: @This()) ?bool {...} fn toPtr(me: @This()) ?align(32) *c_void {...} }

07:59 <Hejsil> This would allow you to write you code like this:

08:00 <Hejsil> if (me.toBool()) |b| {} else if (me.toPtr()) |p| {} else {}

08:01 <Hejsil> You could also convert it to a union: switch (me.toUnion) {T.Bool => |b| {}, T.Ptr => |p| {}}

08:02 <Hejsil> me.toUnion()*

09:15 <daurnimator> Hejsil: hmmm. what about this if we had anonymous unions: union { packed struct { Ptr: align(2) *cvoid, isPtr: bool }, packed struct { Bool: bool, _: u63}, tag(self: *This()) @tagType(*This()) { if (self.isPtr) { return @typeOf(self.Ptr) } else { return @typeOf(self.Bool) } } }

09:21 <Hejsil> Well, packed struct { Ptr: align(2) *cvoid, isPtr: bool } wont work, as isPtr is a bit outside the pointers bits. Also, it seems that your tag function tries to return a type a runtime

09:24 <Hejsil> packed union { Data: packed struct { b: bool, _: u62, isPtr: bool }, Ptr: *align(2) c_void, } could work to represent your data I think

09:25 <Hejsil> What is this even used for. Seems like a fearly complex packing of data

09:28 <daurnimator> Hejsil: it's a simplified example of what I'm looking at doing

09:32 <daurnimator> Hejsil: one thing I'm looking at is implementing the maple tree in zig. https://www.youtube.com/watch?v=-Bw-HWcrnss&t=935

10:29 <tiehuis> Added a zig jpg image writer to this repository if anyone happens to need one: https://github.com/tiehuis/zig-raytrace

11:04 <daurnimator> Hejsil: the idea is that *most* pointers are align(4), so you can store them "inline". otherwise they are a pointer to another another area. with a tag.

11:05 <daurnimator> one of the more interesting things in a maple tree IMO is the "sparse" format, the value idea is: {x, val1, y, val2, z }. which says that between x and y, the value is val_1, between y and z it is val_2

11:06 <daurnimator> and the value is another tree: which can be an inline pointer, a value, or a pointer to another dense or sparse node

11:07 <daurnimator> the size of a sparse node {w,val0,x,val1,y,val2,z} is ideally made to be the size of a cache line

11:07 <daurnimator> and the whole thing can be made thread-safe!

11:43 <Hejsil> daurnimator, i see. One thing we might want is more control over the layout of tagged unions (at least packed ones).

11:45 <Hejsil> So: packed union(enum(u1)){ Bool: packed struct { b: bool, _: u62 }, Ptr: u63, __tag: u1 }

11:45 <Hejsil> Where __tag is just a made up way of specifying where the tag is in the union

11:46 <Hejsil> You would still need to @bitCast your union to the ptr

11:46 <Hejsil> Ooh wait, we need usize and not u64

11:46 <Hejsil> Hmmm

12:12 <schme245> hello! I want to take the first 4 bytes of a byte array and convert that to a u32. here's my attempt:

12:12 <schme245> var block: [8]u8 = undefined;

12:12 <schme245> // ...

12:12 <schme245> // some code to fill the block

12:12 <schme245> // ...

12:12 <schme245> const left: u32 = @bitCast(u32, @truncate(u32, @ptrToInt(block[0..3].ptr)));

12:12 <schme245> is this correct? is there a better way to do it?

12:14 <euantor> @schme245: check out `std.mem.readIntSlice`: https://github.com/ziglang/zig/blob/master/std/mem.zig#L529

12:14 <euantor> That's the easy way to do it :D

12:16 <schme245> perfect, thanks! :D

12:29 <Hejsil> In case you know that your bytes are of the platforms endianess, you can just use @bytesToSlice(u32, block[0..4])[0]

18:26 <donpdonp> here's another webasm oddity. in zig i can export fn setup() [*]const u8 {} and the function 'setup' will be in the .wasm file, where without the export it wouldnt be 'exported' into the wasm. the problem im running into is I need setup to be an export in the wasm, and its not.

19:01 <donpdonp> ah nevermind. zig HEAD fixes it :)

19:45 <schme245> how do i bitshift left with a runtime value?

19:45 <schme245> comptime const indices = [8]u8{58, 50, 42, 34, 26, 18, 10, 2};

19:45 <schme245> for (indices) |i| {

19:45 <schme245> x ^ (1 << i);

19:45 <schme245> }

19:45 <schme245> error: LHS of shift must be an integer type, or RHS must be compile-time known

19:45 <schme245> x ^ (1 << i);

20:07 <schme245> ahh, x ^ (u64(1) << i) does the trick

21:18 <emekankurumeh[m]> i wish zig could get some better type inference, but being explicit about types doesn't really hurt either.

22:04 <daurnimator> emekankurumeh[m]: hmm? the only inference that is really missing is return types of functions

22:04 <daurnimator> emekankurumeh[m]: and that was a deliberate design choice

22:04 <daurnimator> emekankurumeh[m]: is there any other place you'd like it to be better?