\\Performs `result.* = a + b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
\\`ptr` can be `*T`, `fn()`, `?*T`, `?fn()`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value.
\\
\\A [pointer alignment safety check](https://ziglang.org/documentation/0.9.1/#Incorrect-Pointer-Alignment) is added to the generated code to make sure the pointer is aligned as promised.
\\This function returns the number of bytes that this type should be aligned to for the current target to match the C ABI. When the child type of a pointer has this alignment, the alignment can be omitted from the type.
\\The result is a target-specific compile time constant. It is guaranteed to be less than or equal to [@sizeOf(T)](https://ziglang.org/documentation/0.9.1/#sizeOf).
\\Performs [Type Coercion](https://ziglang.org/documentation/0.9.1/#Type-Coercion). This cast is allowed when the conversion is unambiguous and safe, and is the preferred way to convert between types, whenever possible.
\\`@asyncCall` performs an `async` call on a function pointer, which may or may not be an [async function](https://ziglang.org/documentation/0.9.1/#Async-Functions).
\\
\\The provided `frame_buffer` must be large enough to fit the entire function frame. This size can be determined with [@frameSize](https://ziglang.org/documentation/0.9.1/#frameSize). To provide a too-small buffer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
\\`result_ptr` is optional ([null](https://ziglang.org/documentation/0.9.1/#null) may be provided). If provided, the function call will write its result directly to the result pointer, which will be available to read after [await](https://ziglang.org/documentation/0.9.1/#Async-and-Await) completes. Any result location provided to `await` will copy the result from `result_ptr`.
\\
\\```zig
\\const std = @import("std");
\\const expect = std.testing.expect;
\\test "async fn pointer in a struct field" {
\\ var data: i32 = 1;
\\ const Foo = struct {
\\ bar: fn (*i32) callconv(.Async) void,
\\ };
\\ var foo = Foo{ .bar = func };
\\ var bytes: [64]u8 align(@alignOf(@Frame(func))) = undefined;
\\ const f = @asyncCall(&bytes, {}, foo.bar, .{&data});
\\Works at compile-time if `value` is known at compile time. It's a compile error to bitcast a struct to a scalar type of the same size since structs have undefined layout. However if the struct is packed then it works.
\\Returns the bit offset of a field relative to its containing struct.
\\
\\For non [packed structs](https://ziglang.org/documentation/0.9.1/#packed-struct), this will always be divisible by `8`. For packed structs, non-byte-aligned fields will share a byte offset, but they will have different bit offsets.
,
.arguments=&.{
"comptime T: type",
"comptime field_name: []const u8",
},
},
.{
.name="@boolToInt",
.signature="@boolToInt(value: bool) u1",
.snippet="@boolToInt(${1:value: bool})",
.documentation=
\\Converts `true` to `@as(u1, 1)` and `false` to `@as(u1, 0)`.
\\
\\If the value is known at compile-time, the return type is `comptime_int` instead of `u1`.
\\This function returns the number of bits it takes to store `T` in memory if the type were a field in a packed struct/union. The result is a target-specific compile time constant.
\\
\\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`.
,
.arguments=&.{
"comptime T: type",
},
},
.{
.name="@breakpoint",
.signature="@breakpoint()",
.snippet="@breakpoint()",
.documentation=
\\This function inserts a platform-specific debug trap instruction which causes debuggers to break there.
\\
\\This function is only valid within function scope.
\\`T` must be an integer type with bit count evenly divisible by 8.
\\
\\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
\\
\\Swaps the byte order of the integer. This converts a big endian integer to a little endian integer, and converts a little endian integer to a big endian integer.
\\
\\Note that for the purposes of memory layout with respect to endianness, the integer type should be related to the number of bytes reported by [@sizeOf](https://ziglang.org/documentation/0.9.1/#sizeOf) bytes. This is demonstrated with `u24`. `@sizeOf(u24) == 4`, which means that a `u24` stored in memory takes 4 bytes, and those 4 bytes are what are swapped on a little vs big endian system. On the other hand, if `T` is specified to be `u24`, then only 3 bytes are reversed.
\\This function parses C code and imports the functions, types, variables, and compatible macro definitions into a new empty struct type, and then returns that type.
\\
\\`expression` is interpreted at compile time. The builtin functions `@cInclude`, `@cDefine`, and `@cUndef` work within this expression, appending to a temporary buffer which is then parsed as C code.
\\
\\Usually you should only have one `@cImport` in your entire application, because it saves the compiler from invoking clang multiple times, and prevents inline functions from being duplicated.
\\
\\Reasons for having multiple `@cImport` expressions would be:
\\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
\\
\\This function counts the number of most-significant (leading in a big-Endian sense) zeroes in an integer.
\\
\\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
\\
\\If `operand` is zero, `@clz` returns the bit width of integer type `T`.
\\If you are using cmpxchg in a loop, [@cmpxchgWeak](https://ziglang.org/documentation/0.9.1/#cmpxchgWeak) is the better choice, because it can be implemented more efficiently in machine instructions.
\\
\\`T` must be a pointer, a `bool`, a float, an integer or an enum.
\\
\\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).`
\\If you are using cmpxchg in a loop, the sporadic failure will be no problem, and `cmpxchgWeak` is the better choice, because it can be implemented more efficiently in machine instructions. However if you need a stronger guarantee, use [@cmpxchgStrong](https://ziglang.org/documentation/0.9.1/#cmpxchgStrong).
\\
\\`T` must be a pointer, a `bool`, a float, an integer or an enum.
\\
\\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).`
\\This function, when semantically analyzed, causes a compile error with the message `msg`.
\\
\\There are several ways that code avoids being semantically checked, such as using `if` or `switch` with compile time constants, and `comptime` functions.
,
.arguments=&.{
"comptime msg: []u8",
},
},
.{
.name="@compileLog",
.signature="@compileLog(args: ...)",
.snippet="@compileLog(${1:args: ...})",
.documentation=
\\This function prints the arguments passed to it at compile-time.
\\
\\To prevent accidentally leaving compile log statements in a codebase, a compilation error is added to the build, pointing to the compile log statement. This error prevents code from being generated, but does not otherwise interfere with analysis.
\\
\\This function can be used to do "printf debugging" on compile-time executing code.
\\
\\```zig
\\const print = @import("std").debug.print;
\\const num1 = blk: {
\\ var val1: i32 = 99;
\\ @compileLog("comptime val1 = ", val1);
\\ val1 = val1 + 1;
\\ break :blk val1;
\\};
\\test "main" {
\\ @compileLog("comptime in main");
\\ print("Runtime in main, num1 = {}.\n", .{num1});
\\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
\\
\\This function counts the number of least-significant (trailing in a big-Endian sense) zeroes in an integer.
\\
\\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
\\
\\If `operand` is zero, `@ctz` returns the bit width of integer type `T`.
\\Floored division. Rounds toward negative infinity. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`.
\\Truncated division. Rounds toward zero. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`.
\\This function returns a compile time constant pointer to null-terminated, fixed-size array with length equal to the byte count of the file given by `path`. The contents of the array are the contents of the file. This is equivalent to a [string literal](https://ziglang.org/documentation/0.9.1/#String-Literals-and-Unicode-Code-Point-Literals) with the file contents.
\\
\\`path` is absolute or relative to the current file, just like `@import`.
\\This function returns the string representation of an error. The string representation of `error.OutOfMem` is `"OutOfMem"`.
\\
\\If there are no calls to `@errorName` in an entire application, or all calls have a compile-time known value for `err`, then no error name table will be generated.
\\If the binary is built with error return tracing, and this function is invoked in a function that calls a function with an error or error union return type, returns a stack trace object. Otherwise returns [null](https://ziglang.org/documentation/0.9.1/#null).
\\Converts an error value from one error set to another error set. Attempting to convert an error which is not in the destination error set results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
\\ - An identifier (`x`) identifying a [function](https://ziglang.org/documentation/0.9.1/#Functions) or a [variable](https://ziglang.org/documentation/0.9.1/#Container-Level-Variables).
\\ - Field access (`x.y`) looking up a [function](https://ziglang.org/documentation/0.9.1/#Functions) or a [variable](https://ziglang.org/documentation/0.9.1/#Container-Level-Variables).
\\This builtin can be called from a [comptime](https://ziglang.org/documentation/0.9.1/#comptime) block to conditionally export symbols. When
\\`declaration`is a function with the C calling convention and `options.linkage` is `Strong`, this is equivalent to the `export` keyword used on a function:
\\Note that even when using `export`, the `@"foo"` syntax for [identifiers](https://ziglang.org/documentation/0.9.1/#Identifiers) can be used to choose any string for the symbol name:
\\Converts the integer part of a floating point number to the destination type.
\\
\\If the integer part of the floating point number cannot fit in the destination type, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
,
.arguments=&.{
"comptime DestType: type",
"float: anytype",
},
},
.{
.name="@frame",
.signature="@frame() *@Frame(func)",
.snippet="@frame()",
.documentation=
\\This function returns a pointer to the frame for a given function. This type can be [coerced](https://ziglang.org/documentation/0.9.1/#Type-Coercion) to `anyframe->T` and to `anyframe`, where `T` is the return type of the function in scope.
\\
\\This function does not mark a suspension point, but it does cause the function in scope to become an [async function](https://ziglang.org/documentation/0.9.1/#Async-Functions).
,
.arguments=&.{},
},
.{
.name="@Frame",
.signature="@Frame(func: anytype) type",
.snippet="@Frame(${1:func: anytype})",
.documentation=
\\This function returns the frame type of a function. This works for [Async Functions](https://ziglang.org/documentation/0.9.1/#Async-Functions) as well as any function without a specific calling convention.
\\This type is suitable to be used as the return type of [async](https://ziglang.org/documentation/0.9.1/#Async-and-Await) which allows one to, for example, heap-allocate an async function frame:
\\This function returns the base pointer of the current stack frame.
\\
\\The implications of this are target specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations.
\\
\\This function is only valid within function scope.
,
.arguments=&.{},
},
.{
.name="@frameSize",
.signature="@frameSize() usize",
.snippet="@frameSize()",
.documentation=
\\This is the same as `@sizeOf(@Frame(func))`, where `func` may be runtime-known.
\\
\\This function is typically used in conjunction with [@asyncCall](https://ziglang.org/documentation/0.9.1/#asyncCall).
\\Returns whether or not a [struct](https://ziglang.org/documentation/0.9.1/#struct), [enum](https://ziglang.org/documentation/0.9.1/#enum), or [union](https://ziglang.org/documentation/0.9.1/#union) has a declaration matching `name`.
\\
\\```zig
\\const std = @import("std");
\\const expect = std.testing.expect;
\\const Foo = struct {
\\ nope: i32,
\\ pub var blah = "xxx";
\\ const hi = 1;
\\};
\\test "@hasDecl" {
\\ try expect(@hasDecl(Foo, "blah"));
\\ // Even though `hi` is private, @hasDecl returns true because this test is
\\ // in the same file scope as Foo. It would return false if Foo was declared
\\Returns whether the field name of a struct, union, or enum exists.
\\
\\The result is a compile time constant.
\\
\\It does not include functions, variables, or constants.
,
.arguments=&.{
"comptime Container: type",
"comptime name: []const u8",
},
},
.{
.name="@import",
.signature="@import(comptime path: []u8) type",
.snippet="@import(${1:comptime path: []u8})",
.documentation=
\\This function finds a zig file corresponding to `path` and adds it to the build, if it is not already added.
\\
\\Zig source files are implicitly structs, with a name equal to the file's basename with the extension truncated. `@import` returns the struct type corresponding to the file.
\\
\\Declarations which have the `pub` keyword may be referenced from a different source file than the one they are declared in.
\\
\\`path` can be a relative path or it can be the name of a package. If it is a relative path, it is relative to the file that contains the `@import` function call.
\\Converts an integer to another integer while keeping the same numerical value. Attempting to convert a number which is out of range of the destination type results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
\\
\\```zig
\\test "integer cast panic" {
\\ var a: u16 = 0xabcd;
\\ var b: u8 = @intCast(u8, a);
\\ _ = b;
\\}
\\```
\\To truncate the significant bits of a number out of range of the destination type, use [@truncate](https://ziglang.org/documentation/0.9.1/#truncate).
\\
\\If `T` is `comptime_int`, then this is semantically equivalent to [Type Coercion](https://ziglang.org/documentation/0.9.1/#Type-Coercion).
\\Converts an integer into an [enum](https://ziglang.org/documentation/0.9.1/#enum) value.
\\
\\Attempting to convert an integer which represents no value in the chosen enum type invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
\\Converts from the integer representation of an error into [The Global Error Set](https://ziglang.org/documentation/0.9.1/#The-Global-Error-Set) type.
\\
\\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes.
\\
\\Attempting to convert an integer that does not correspond to any error results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
\\Converts an integer to the closest floating point representation. To convert the other way, use [@floatToInt](https://ziglang.org/documentation/0.9.1/#floatToInt). This cast is always safe.
\\Converts an integer to a [pointer](https://ziglang.org/documentation/0.9.1/#Pointers). To convert the other way, use [@ptrToInt](https://ziglang.org/documentation/0.9.1/#ptrToInt). Casting an address of 0 to a destination type which in not [optional](https://ziglang.org/documentation/0.9.1/#Optional-Pointers) and does not have the `allowzero` attribute will result in a [Pointer Cast Invalid Null](https://ziglang.org/documentation/0.9.1/#Pointer-Cast-Invalid-Null) panic when runtime safety checks are enabled.
\\
\\If the destination pointer type does not allow address zero and `address` is zero, this invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
,
.arguments=&.{
"comptime DestType: type",
"address: usize",
},
},
.{
.name="@maximum",
.signature="@maximum(a: T, b: T) T",
.snippet="@maximum(${1:a: T}, ${2:b: T})",
.documentation=
\\Returns the maximum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
\\
\\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
\\The optimizer is intelligent enough to turn the above snippet into a memset.
\\
\\There is also a standard library function for this:
\\
\\```zig
\\const mem = @import("std").mem;
\\mem.set(u8, dest, c);
\\```
,
.arguments=&.{
"dest: [*]u8",
"c: u8",
"byte_count: usize",
},
},
.{
.name="@minimum",
.signature="@minimum(a: T, b: T) T",
.snippet="@minimum(${1:a: T}, ${2:b: T})",
.documentation=
\\Returns the minimum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise.
\\
\\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned.
,
.arguments=&.{
"a: T",
"b: T",
},
},
.{
.name="@wasmMemorySize",
.signature="@wasmMemorySize(index: u32) u32",
.snippet="@wasmMemorySize(${1:index: u32})",
.documentation=
\\This function returns the size of the Wasm memory identified by `index` as an unsigned value in units of Wasm pages. Note that each Wasm page is 64KB in size.
\\
\\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.
\\This function increases the size of the Wasm memory identified by `index` by `delta` in units of unsigned number of Wasm pages. Note that each Wasm page is 64KB in size. On success, returns previous memory size; on failure, if the allocation fails, returns -1.
\\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.
\\Modulus division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.9.1/#Remainder-Division-by-Zero) when runtime safety checks are enabled.
\\Performs `result.* = a * b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
\\Invokes the panic handler function. By default the panic handler function calls the public `panic` function exposed in the root source file, or if there is not one specified, the `std.builtin.default_panic` function from `std/builtin.zig`.
\\
\\Generally it is better to use `@import("std").debug.panic`. However, `@panic` can be useful for 2 scenarios:
\\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors).
\\
\\Counts the number of bits set in an integer.
\\
\\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type.
\\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a noop. This function has no effect on the behavior of the program, only on the performance characteristics.
\\
\\The `ptr` argument may be any pointer type and determines the memory address to prefetch. This function does not dereference the pointer, it is perfectly legal to pass a pointer to invalid memory to this function and no illegal behavior will result.
\\Converts a pointer of one type to a pointer of another type.
\\
\\[Optional Pointers](https://ziglang.org/documentation/0.9.1/#Optional-Pointers) are allowed. Casting an optional pointer which is [null](https://ziglang.org/documentation/0.9.1/#null) to a non-optional pointer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
,
.arguments=&.{
"comptime DestType: type",
"value: anytype",
},
},
.{
.name="@ptrToInt",
.signature="@ptrToInt(value: anytype) usize",
.snippet="@ptrToInt(${1:value: anytype})",
.documentation=
\\Converts `value` to a `usize` which is the address of the pointer. `value` can be one of these types:
\\Remainder division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.9.1/#Remainder-Division-by-Zero) when runtime safety checks are enabled.
\\For a function that returns an error code, see `@import("std").math.rem`.
,
.arguments=&.{
"numerator: T",
"denominator: T",
},
},
.{
.name="@returnAddress",
.signature="@returnAddress() usize",
.snippet="@returnAddress()",
.documentation=
\\This function returns the address of the next machine code instruction that will be executed when the current function returns.
\\
\\The implications of this are target specific and not consistent across all platforms.
\\
\\This function is only valid within function scope. If the function gets inlined into a calling function, the returned address will apply to the calling function.
\\Selects values element-wise from `a` or `b` based on `pred`. If `pred[i]` is `true`, the corresponding element in the result will be `a[i]` and otherwise `b[i]`.
\\ - `Optimized` - Floating point operations may do all of the following:
\\ - Assume the arguments and result are not NaN. Optimizations are required to retain defined behavior over NaNs, but the value of the result is undefined.
\\ - Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined.
\\ - Treat the sign of a zero argument or result as insignificant.
\\ - Use the reciprocal of an argument rather than perform division.
\\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-and-add).
\\ - Perform algebraically equivalent transformations that may change results in floating point (e.g. reassociate).
\\The floating point mode is inherited by child scopes, and can be overridden in any scope. You can set the floating point mode in a struct or module scope by using a comptime block.
\\`). For unsigned integers, the result is [undefined](https://ziglang.org/documentation/0.9.1/#undefined) if any 1 bits are shifted out. For signed integers, the result is [undefined](https://ziglang.org/documentation/0.9.1/#undefined) if any bits that disagree with the resultant sign bit are shifted out.
\\Constructs a new [vector](https://ziglang.org/documentation/0.9.1/#Vectors) by selecting elements from `a` and `b` based on `mask`.
\\
\\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator from indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`).
\\
\\For each element of `mask`, if it or the selected value from `a` or `b` is `undefined`, then the resulting element is `undefined`.
\\
\\`a_len` and `b_len` may differ in length. Out-of-bounds element indexes in `mask` result in compile errors.
\\
\\If `a` or `b` is `undefined`, it is equivalent to a vector of all `undefined` with the same length as the other vector. If both vectors are `undefined`, `@shuffle` returns a vector with all elements `undefined`.
\\`E` must be an [integer](https://ziglang.org/documentation/0.9.1/#Integers), [float](https://ziglang.org/documentation/0.9.1/#Floats), [pointer](https://ziglang.org/documentation/0.9.1/#Pointers), or `bool`. The mask may be any vector length, and its length determines the result length.
\\This function returns the number of bytes it takes to store `T` in memory. The result is a target-specific compile time constant.
\\
\\This size may contain padding bytes. If there were two consecutive T in memory, this would be the offset in bytes between element at index 0 and the element at index 1. For [integer](https://ziglang.org/documentation/0.9.1/#Integers), consider whether you want to use `@sizeOf(T)` or `@typeInfo(T).Int.bits`.
\\
\\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`.
\\`scalar` must be an [integer](https://ziglang.org/documentation/0.9.1/#Integers), [bool](https://ziglang.org/documentation/0.9.1/#Primitive-Types), [float](https://ziglang.org/documentation/0.9.1/#Floats), or [pointer](https://ziglang.org/documentation/0.9.1/#Pointers).
\\Transforms a [vector](https://ziglang.org/documentation/0.9.1/#Vectors) into a scalar value by performing a sequential horizontal reduction of its elements using the specified operator `op`.
\\
\\Not every operator is available for every vector element type:
\\ - `.And`, `.Or`, `.Xor` are available for `bool` vectors,
\\ - `.Min`, `.Max`, `.Add`, `.Mul` are available for [floating point](https://ziglang.org/documentation/0.9.1/#Floats) vectors,
\\ - Every operator is available for [integer](https://ziglang.org/documentation/0.9.1/#Integers) vectors.
\\Note that `.Add` and `.Mul` reductions on integral types are wrapping; when applied on floating point types the operation associativity is preserved, unless the float mode is set to `Optimized`.
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that
\\[some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026).
\\Performs `result.* = a - b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`.
\\Converts an enum value or union value to a string literal representing the name.
\\
\\If the enum is non-exhaustive and the tag value does not map to a name, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior).
\\Returns the innermost struct, enum, or union that this function call is inside. This can be useful for an anonymous struct that needs to refer to itself:
\\Type information of [structs](https://ziglang.org/documentation/0.9.1/#struct), [unions](https://ziglang.org/documentation/0.9.1/#union), [enums](https://ziglang.org/documentation/0.9.1/#enum), and [error sets](https://ziglang.org/documentation/0.9.1/#Error-Set-Type) has fields which are are guaranteed to be in the same order as appearance in the source file.
\\
\\Type information of [structs](https://ziglang.org/documentation/0.9.1/#struct), [unions](https://ziglang.org/documentation/0.9.1/#union), [enums](https://ziglang.org/documentation/0.9.1/#enum), and [opaques](https://ziglang.org/documentation/0.9.1/#opaque) has declarations, which are also guaranteed to be in the same order as appearance in the source file.
,
.arguments=&.{
"comptime T: type",
},
},
.{
.name="@typeName",
.signature="@typeName(T: type) *const [N:0]u8",
.snippet="@typeName(${1:T: type})",
.documentation=
\\This function returns the string representation of a type, as an array. It is equivalent to a string literal of the type name.
,
.arguments=&.{
"T: type",
},
},
.{
.name="@TypeOf",
.signature="@TypeOf(...) type",
.snippet="@TypeOf(${1:...})",
.documentation=
\\`@TypeOf` is a special builtin function that takes any (nonzero) number of expressions as parameters and returns the type of the result, using [Peer Type Resolution](https://ziglang.org/documentation/0.9.1/#Peer-Type-Resolution).
\\This is the same thing as [union](https://ziglang.org/documentation/0.9.1/#union) initialization syntax, except that the field name is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known value rather than an identifier token.
\\
\\`@unionInit` forwards its [result location](https://ziglang.org/documentation/0.9.1/#Result-Location-Semantics) to `init_expr`.
