fields

Function parameters

Parameters

T:type

Functions in this namespace

Functions

TrailerFlags
stringToEnum: Returns the variant of an enum type, `T`, which is named `str`, or `null` if no such variant exists.
alignment: Returns the alignment of type T.
Child: Given a parameterized type (array, vector, pointer, optional), returns the "child type".
Elem: Given a "memory span" type (array, slice, vector, or pointer to such), returns the "element type".
sentinel: Given a type which can have a sentinel e.g.
Sentinel: Given a "memory span" type, returns the same type except with the given sentinel value.
containerLayout
declarations: Instead of this function, prefer to use e.g.
declarationInfo
fields
fieldInfo
fieldNames
tags: Given an enum or error set type, returns a pointer to an array containing all tags for that
FieldEnum: Returns an enum with a variant named after each field of `T`.
DeclEnum
Tag
activeTag: Returns the active tag of a tagged union
TagPayloadByName: Deprecated: Use @FieldType(U, tag_name)
TagPayload: Deprecated: Use @FieldType(U, @tagName(tag))
eql: Compares two of any type for equality.
intToEnum: Deprecated: use `std.enums.fromInt` instead and handle null instead of an error.
fieldIndex: Given a type and a name, return the field index according to source order.
declList: Returns a slice of pointers to public declarations of a namespace.
Int
Float
ArgsTuple: For a given function type, returns a tuple type which fields will
Tuple: For a given anonymous list of types, returns a new tuple type
isError: Returns whether `error_union` contains an error.
hasFn: Returns true if a type has a namespace and the namespace contains `name`;
hasMethod: Returns true if a type has a `name` method; `false` otherwise.
hasUniqueRepresentation: True if every value of the type `T` has a unique bit pattern representing it.

Error sets in this namespace

Error Sets

IntToEnumError: Deprecated: use `std.enums.fromInt` instead and handle null.

Source

Implementation

pub fn fields(comptime T: type) switch (@typeInfo(T)) {
    .@"struct" => []const Type.StructField,
    .@"union" => []const Type.UnionField,
    .@"enum" => []const Type.EnumField,
    .error_set => []const Type.Error,
    else => @compileError("Expected struct, union, error set or enum type, found '" ++ @typeName(T) ++ "'"),
} {
    return switch (@typeInfo(T)) {
        .@"struct" => |info| info.fields,
        .@"union" => |info| info.fields,
        .@"enum" => |info| info.fields,
        .error_set => |errors| errors.?, // must be non global error set
        else => @compileError("Expected struct, union, error set or enum type, found '" ++ @typeName(T) ++ "'"),
    };
}