Add std.meta #1662

tgschultz · 2018-10-18T15:18:10Z

Added the beginning of std.meta from the branch started by @Hejsil and @andrewrk, which is intended to replace a lot of built-in functions over time, as well as std.meta.trait which is a collection of shortcuts to simple type introspections like determining if a type has an fn definition with a specific name.

Sync with upstream master

sync

Sync to latest

Ziggurat somehow did not get updated to latest syntax

f32 float casts somehow not updated to latest syntax

Sync with upstream

sync

Hejsil · 2018-10-18T15:27:16Z

std/meta/index.zig

+/// Otherwise it returns the type as-is. 
+pub fn UnwrapContainer(comptime T: type) type
+{
+    comptime


Pretty sure functions returning type are always evaluated at comptime

Chalk it up to paranoia from seeing too many bugs due to something being evaluated as runtime for non-obvious reasons.

Hejsil · 2018-10-18T15:33:44Z

std/meta/index.zig

+
+
+///Returns the active tag of a tagged union
+pub fn activeTag(u: var) @TagType(UnwrapContainer(@typeOf(u)))


I don't think this function should take pointers and deref it. It should just take the value, and the user is responsible for the deref.

That makes sense, given that the compiler should ensure that no copies of large structs occur.

Hejsil · 2018-10-18T15:38:57Z

std/meta/index.zig

+}
+///Given a pointer to a single item, returns a slice of the underlying bytes, preserving the
+/// pointer's const-ness.
+pub fn bytes(ptr: var) BytesReturnType(@typeOf(ptr))


Maybe this should be in std.mem instead. We should also probably return an array pointer instead of a slice, as we know the size of the data we are returning. I have a simular implementation of this here. I think we could have toBytes and asBytes where asBytes return a slice with the correct attributes, and toBytes just returns a copy of the data as bytes.

And maybe we should also have a bytesToValue and bytesAsValue that takes an array/array pointer respectively and returns a packed value/pointer to packed value.

Makes sense to me.

std/meta/index.zig

Hejsil · 2018-10-18T15:47:11Z

std/meta/index.zig

+pub fn containerEql(container_a: var, container_b: var) bool
+{
+    const T = UnwrapContainer(@typeOf(container_a));
+    debug.assert(UnwrapContainer(@typeOf(container_b)) == T);


Again, I don't think we should take pointers. Let the function take values, and let the user deref.

Hejsil · 2018-10-18T15:48:36Z

std/meta/index.zig

+
+///Compares two structs or (tagged) unions for equality on a field level
+/// so that padding bytes are not relevant.
+pub fn containerEql(container_a: var, container_b: var) bool


Why only containers? We could do a generic eql that supports all types.

Actually that was the original implementation, but it seemed to me that it might be a bad idea to have such a broad implementation. For instance, the only reasonable way to compare two untagged unions is to use mem.eql, but that comparison could be wrong. If the user is used to just calling meta.eql on everything, including untagged unions, that comparison will sometimes fail when it would be expected to succeed.

Makes sense, but we could just make untagged unions call @compileError. Most types compare equal just fine.

std/meta/trait.zig

Hejsil · 2018-10-18T15:54:30Z

std/meta/trait.zig

+    };
+
+    debug.assert(hasField("value")(TestStruct));
+    debug.assert(hasField("value")(*TestStruct));


I know, that . can access through pointers, but Idk if we really wanna "lie" to the user because of this. The pointer does not have any fields. . just does a little magic.

In generic code, the user probably doesn't care if they were passed a pointer or not, as long as they can call/access some needed function/field.

Actually, I think you're right. Instead we'll have the user call UnwrapContainer(T) --I am all ears for naming suggestions-- themselves if that's the behavior they want.

Hejsil · 2018-10-18T15:56:17Z

std/meta/trait.zig

+        if(is(builtin.TypeId.Pointer)(T))
+        {
+            const info = @typeInfo(T);
+            return info.Pointer.size != builtin.TypeInfo.Pointer.Size.One;


We can index array pointers (*[N]T)

Hejsil

Looks pretty good now (only two small things). The trait function will be really useful if we ever get var<func> :)

Hejsil · 2018-10-18T19:56:13Z

std/meta/index.zig

+const TypeId = builtin.TypeId;
+const TypeInfo = builtin.TypeInfo;
+
+pub fn UnwrapContainer(comptime T: type) type


Now, we probably don't need this anymore :)

Maybe. I think it might still be useful for generic code that doesn't care if it is passed a pointer or not as long as it can call/access var.whatever. I used to do this a lot before #733, so it might not be as useful an idea now. I'll think on it for a bit.

Hejsil · 2018-10-18T19:59:35Z

std/meta/index.zig

+
+///Compares two structs or (tagged) unions for equality on a field level
+/// so that padding bytes are not relevant.
+pub fn containerEql(container_a: var, container_b: @typeOf(container_a)) bool


I still think we probably just want a fully generic equal, if we're gonna have this one

Hejsil · 2018-10-19T17:40:23Z

std/meta/index.zig

+
+            //This is the only reasonable way to handle an untagged union,
+            // but it will report a false negative in many circumstances.
+            return std.mem.eql(u8, mem.asBytes(&a), mem.asBytes(&b));


It's probably better if this is a compiler error, to avoid the bugs, where padding bytes are different

Hejsil · 2018-10-19T18:00:08Z

Other than some of the code not following the style of std, this PR LGTM

Hejsil · 2018-10-19T18:43:36Z

std/mem.zig

+pub fn bytesAsValue(comptime T: type, bytes: var) BytesAsValueReturnType(T, @typeOf(bytes))
+{
+    return @ptrCast(BytesAsValueReturnType(T, @typeOf(bytes)), 
+        @alignCast(comptime meta.alignment(T), bytes));


This cast failes on macos, because the bytes we pass in are not aligned with our type. Maybe we should return *align(1) T?

And maybe asBytes should return *align(comptime alignment(@typeOf(ptr))) [@sizeOf(@typeOf(ptr))]

std/mem.zig

…Removed to* variations as they are trivially replicated with 2 characters at the as* callsites.

… bytesAsValue alignment match alignment of byte buffer. I'm not 100% sure that's actually a good idea though.

tgschultz added 9 commits June 6, 2018 06:47

Merge pull request #3 from ziglang/master

44143db

Sync with upstream master

Merge pull request #4 from ziglang/master

fba2653

sync

Merge pull request #5 from ziglang/master

041a893

Sync to latest

Fix old syntax in rand

c3890a1

Ziggurat somehow did not get updated to latest syntax

Fix broken float casts

47cf2aa

f32 float casts somehow not updated to latest syntax

Merge pull request #6 from ziglang/master

707b222

Sync with upstream

Merge pull request #7 from ziglang/master

8f0f475

sync

Merge pull request #8 from ziglang/master

37dae88

sync

Added std.meta

ec472e2

Hejsil reviewed Oct 18, 2018

View reviewed changes

tgschultz added 5 commits October 18, 2018 11:24

Changes based on review feedback

2dbab73

Removed internal use of "UnwrapContainer". Added *[N]T as indexable.

fd33c34

Added test case for indexable *[N]T

aba87ff

Removed byteAlignedSizeOf, removed comptime blocks

6ddf6d7

Add meta to std/index.zig

6ea5c80

Hejsil reviewed Oct 18, 2018

View reviewed changes

tgschultz added 3 commits October 19, 2018 08:29

meta.alignment changes

bd3b34e

Genericized meta.eql, added std.mem byte functions

4be1a89

Removed UnwrapContainer as no longer necessary and probably useless.

fa8d2a7

Hejsil reviewed Oct 19, 2018

View reviewed changes

compile error when calling meta.eql on untagged unions

741b733

Hejsil reviewed Oct 19, 2018

View reviewed changes

tgschultz commented Oct 19, 2018

View reviewed changes

std/mem.zig Show resolved Hide resolved

tgschultz added 2 commits October 19, 2018 14:24

Altered asBytes and bytesAsValue to have more appropriate alignment. …

c3f64fb

…Removed to* variations as they are trivially replicated with 2 characters at the as* callsites.

Was convinced to re-add to* variations for convenience & saftey. Made…

31eb068

… bytesAsValue alignment match alignment of byte buffer. I'm not 100% sure that's actually a good idea though.

Hejsil merged commit 2a3fdd5 into ziglang:master Oct 19, 2018

This was referenced Oct 20, 2018

Proposal: User definable type constraints on polymorphic parameters #1669

Closed

Add std.meta to deployment #1670

Merged

tgschultz deleted the std-meta branch October 20, 2018 15:12

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Add std.meta #1662

Add std.meta #1662

tgschultz commented Oct 18, 2018

Hejsil Oct 18, 2018

tgschultz Oct 18, 2018 •

edited

Loading

Hejsil Oct 18, 2018

tgschultz Oct 18, 2018

Hejsil Oct 18, 2018

Hejsil Oct 18, 2018

tgschultz Oct 18, 2018

Hejsil Oct 18, 2018

Hejsil Oct 18, 2018

tgschultz Oct 18, 2018

Hejsil Oct 18, 2018

Hejsil Oct 18, 2018

tgschultz Oct 18, 2018

tgschultz Oct 18, 2018

Hejsil Oct 18, 2018

Hejsil left a comment

Hejsil Oct 18, 2018

tgschultz Oct 18, 2018

Hejsil Oct 18, 2018

Hejsil Oct 19, 2018

Hejsil commented Oct 19, 2018

Hejsil Oct 19, 2018

Hejsil Oct 19, 2018 •

edited

Loading



		///Returns the active tag of a tagged union
		pub fn activeTag(u: var) @TagType(UnwrapContainer(@typeOf(u)))

Add std.meta #1662

Add std.meta #1662

Conversation

tgschultz commented Oct 18, 2018

Choose a reason for hiding this comment

tgschultz Oct 18, 2018 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Hejsil left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Hejsil commented Oct 19, 2018

Choose a reason for hiding this comment

Hejsil Oct 19, 2018 • edited Loading

Choose a reason for hiding this comment

tgschultz Oct 18, 2018 •

edited

Loading

Hejsil Oct 19, 2018 •

edited

Loading