Rename @typeOf to @TypeOf in the language reference
This commit is contained in:
Robin Voetter
Andrew Kelley
parent
8c096707b7
commit
30715560c8
|
|
@ -307,7 +307,7 @@ pub fn main() void {
|
|||
assert(optional_value == null);
|
||||
|
||||
warn("\noptional 1\ntype: {}\nvalue: {}\n", .{
|
||||
@typeName(@typeOf(optional_value)),
|
||||
@typeName(@TypeOf(optional_value)),
|
||||
optional_value,
|
||||
});
|
||||
|
||||
|
|
@ -315,7 +315,7 @@ pub fn main() void {
|
|||
assert(optional_value != null);
|
||||
|
||||
warn("\noptional 2\ntype: {}\nvalue: {}\n", .{
|
||||
@typeName(@typeOf(optional_value)),
|
||||
@typeName(@TypeOf(optional_value)),
|
||||
optional_value,
|
||||
});
|
||||
|
||||
|
|
@ -323,14 +323,14 @@ pub fn main() void {
|
|||
var number_or_error: anyerror!i32 = error.ArgNotFound;
|
||||
|
||||
warn("\nerror union 1\ntype: {}\nvalue: {}\n", .{
|
||||
@typeName(@typeOf(number_or_error)),
|
||||
@typeName(@TypeOf(number_or_error)),
|
||||
number_or_error,
|
||||
});
|
||||
|
||||
number_or_error = 1234;
|
||||
|
||||
warn("\nerror union 2\ntype: {}\nvalue: {}\n", .{
|
||||
@typeName(@typeOf(number_or_error)),
|
||||
@typeName(@TypeOf(number_or_error)),
|
||||
number_or_error,
|
||||
});
|
||||
}
|
||||
|
|
@ -572,7 +572,7 @@ const mem = @import("std").mem;
|
|||
|
||||
test "string literals" {
|
||||
const bytes = "hello";
|
||||
assert(@typeOf(bytes) == *const [5:0]u8);
|
||||
assert(@TypeOf(bytes) == *const [5:0]u8);
|
||||
assert(bytes.len == 5);
|
||||
assert(bytes[1] == 'e');
|
||||
assert(bytes[5] == 0);
|
||||
|
|
@ -1802,7 +1802,7 @@ const assert = std.debug.assert;
|
|||
test "null terminated array" {
|
||||
const array = [_:0]u8 {1, 2, 3, 4};
|
||||
|
||||
assert(@typeOf(array) == [4:0]u8);
|
||||
assert(@TypeOf(array) == [4:0]u8);
|
||||
assert(array.len == 4);
|
||||
assert(array[4] == 0);
|
||||
}
|
||||
|
|
@ -1885,12 +1885,12 @@ test "address of syntax" {
|
|||
assert(x_ptr.* == 1234);
|
||||
|
||||
// When you get the address of a const variable, you get a const pointer to a single item.
|
||||
assert(@typeOf(x_ptr) == *const i32);
|
||||
assert(@TypeOf(x_ptr) == *const i32);
|
||||
|
||||
// If you want to mutate the value, you'd need an address of a mutable variable:
|
||||
var y: i32 = 5678;
|
||||
const y_ptr = &y;
|
||||
assert(@typeOf(y_ptr) == *i32);
|
||||
assert(@TypeOf(y_ptr) == *i32);
|
||||
y_ptr.* += 1;
|
||||
assert(y_ptr.* == 5679);
|
||||
}
|
||||
|
|
@ -1901,7 +1901,7 @@ test "pointer array access" {
|
|||
// does not support pointer arithmetic.
|
||||
var array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
|
||||
const ptr = &array[2];
|
||||
assert(@typeOf(ptr) == *u8);
|
||||
assert(@TypeOf(ptr) == *u8);
|
||||
|
||||
assert(array[2] == 3);
|
||||
ptr.* += 1;
|
||||
|
|
@ -1953,7 +1953,7 @@ const assert = @import("std").debug.assert;
|
|||
test "@ptrToInt and @intToPtr" {
|
||||
const ptr = @intToPtr(*i32, 0xdeadbeef);
|
||||
const addr = @ptrToInt(ptr);
|
||||
assert(@typeOf(addr) == usize);
|
||||
assert(@TypeOf(addr) == usize);
|
||||
assert(addr == 0xdeadbeef);
|
||||
}
|
||||
{#code_end#}
|
||||
|
|
@ -1968,7 +1968,7 @@ test "comptime @intToPtr" {
|
|||
// ptr is never dereferenced.
|
||||
const ptr = @intToPtr(*i32, 0xdeadbeef);
|
||||
const addr = @ptrToInt(ptr);
|
||||
assert(@typeOf(addr) == usize);
|
||||
assert(@TypeOf(addr) == usize);
|
||||
assert(addr == 0xdeadbeef);
|
||||
}
|
||||
}
|
||||
|
|
@ -1984,7 +1984,7 @@ const assert = @import("std").debug.assert;
|
|||
|
||||
test "volatile" {
|
||||
const mmio_ptr = @intToPtr(*volatile u8, 0x12345678);
|
||||
assert(@typeOf(mmio_ptr) == *volatile u8);
|
||||
assert(@TypeOf(mmio_ptr) == *volatile u8);
|
||||
}
|
||||
{#code_end#}
|
||||
<p>
|
||||
|
|
@ -2041,8 +2041,8 @@ const builtin = @import("builtin");
|
|||
|
||||
test "variable alignment" {
|
||||
var x: i32 = 1234;
|
||||
const align_of_i32 = @alignOf(@typeOf(x));
|
||||
assert(@typeOf(&x) == *i32);
|
||||
const align_of_i32 = @alignOf(@TypeOf(x));
|
||||
assert(@TypeOf(&x) == *i32);
|
||||
assert(*i32 == *align(align_of_i32) i32);
|
||||
if (builtin.arch == builtin.Arch.x86_64) {
|
||||
assert((*i32).alignment == 4);
|
||||
|
|
@ -2063,10 +2063,10 @@ const assert = @import("std").debug.assert;
|
|||
var foo: u8 align(4) = 100;
|
||||
|
||||
test "global variable alignment" {
|
||||
assert(@typeOf(&foo).alignment == 4);
|
||||
assert(@typeOf(&foo) == *align(4) u8);
|
||||
assert(@TypeOf(&foo).alignment == 4);
|
||||
assert(@TypeOf(&foo) == *align(4) u8);
|
||||
const slice = @as(*[1]u8, &foo)[0..];
|
||||
assert(@typeOf(slice) == []align(4) u8);
|
||||
assert(@TypeOf(slice) == []align(4) u8);
|
||||
}
|
||||
|
||||
fn derp() align(@sizeOf(usize) * 2) i32 { return 1234; }
|
||||
|
|
@ -2075,8 +2075,8 @@ fn noop4() align(4) void {}
|
|||
|
||||
test "function alignment" {
|
||||
assert(derp() == 1234);
|
||||
assert(@typeOf(noop1) == fn() align(1) void);
|
||||
assert(@typeOf(noop4) == fn() align(4) void);
|
||||
assert(@TypeOf(noop1) == fn() align(1) void);
|
||||
assert(@TypeOf(noop4) == fn() align(4) void);
|
||||
noop1();
|
||||
noop4();
|
||||
}
|
||||
|
|
@ -2162,8 +2162,8 @@ test "basic slices" {
|
|||
|
||||
// Using the address-of operator on a slice gives a pointer to a single
|
||||
// item, while using the `ptr` field gives an unknown length pointer.
|
||||
assert(@typeOf(slice.ptr) == [*]i32);
|
||||
assert(@typeOf(&slice[0]) == *i32);
|
||||
assert(@TypeOf(slice.ptr) == [*]i32);
|
||||
assert(@TypeOf(&slice[0]) == *i32);
|
||||
assert(@ptrToInt(slice.ptr) == @ptrToInt(&slice[0]));
|
||||
|
||||
// Slices have array bounds checking. If you try to access something out
|
||||
|
|
@ -2208,7 +2208,7 @@ test "slice pointer" {
|
|||
slice[2] = 3;
|
||||
assert(slice[2] == 3);
|
||||
// The slice is mutable because we sliced a mutable pointer.
|
||||
assert(@typeOf(slice) == []u8);
|
||||
assert(@TypeOf(slice) == []u8);
|
||||
|
||||
// You can also slice a slice:
|
||||
const slice2 = slice[2..3];
|
||||
|
|
@ -3566,7 +3566,7 @@ test "for basics" {
|
|||
// This is zero-indexed.
|
||||
var sum2: i32 = 0;
|
||||
for (items) |value, i| {
|
||||
assert(@typeOf(i) == usize);
|
||||
assert(@TypeOf(i) == usize);
|
||||
sum2 += @intCast(i32, i);
|
||||
}
|
||||
assert(sum2 == 10);
|
||||
|
|
@ -3909,7 +3909,7 @@ test "type of unreachable" {
|
|||
// However this assertion will still fail because
|
||||
// evaluating unreachable at compile-time is a compile error.
|
||||
|
||||
assert(@typeOf(unreachable) == noreturn);
|
||||
assert(@TypeOf(unreachable) == noreturn);
|
||||
}
|
||||
}
|
||||
{#code_end#}
|
||||
|
|
@ -4018,7 +4018,7 @@ test "function" {
|
|||
const assert = @import("std").debug.assert;
|
||||
|
||||
comptime {
|
||||
assert(@typeOf(foo) == fn()void);
|
||||
assert(@TypeOf(foo) == fn()void);
|
||||
assert(@sizeOf(fn()void) == @sizeOf(?fn()void));
|
||||
}
|
||||
|
||||
|
|
@ -4062,35 +4062,35 @@ test "pass struct to function" {
|
|||
</p>
|
||||
{#header_close#}
|
||||
{#header_open|Function Parameter Type Inference#}
|
||||
<p>
|
||||
Function parameters can be declared with {#syntax#}var{#endsyntax#} in place of the type.
|
||||
<p>
|
||||
Function parameters can be declared with {#syntax#}var{#endsyntax#} in place of the type.
|
||||
In this case the parameter types will be inferred when the function is called.
|
||||
Use {#link|@typeOf#} and {#link|@typeInfo#} to get information about the inferred type.
|
||||
Use {#link|@TypeOf#} and {#link|@typeInfo#} to get information about the inferred type.
|
||||
</p>
|
||||
{#code_begin|test#}
|
||||
const assert = @import("std").debug.assert;
|
||||
|
||||
fn addFortyTwo(x: var) @typeOf(x) {
|
||||
fn addFortyTwo(x: var) @TypeOf(x) {
|
||||
return x + 42;
|
||||
}
|
||||
|
||||
test "fn type inference" {
|
||||
assert(addFortyTwo(1) == 43);
|
||||
assert(@typeOf(addFortyTwo(1)) == comptime_int);
|
||||
assert(@TypeOf(addFortyTwo(1)) == comptime_int);
|
||||
var y: i64 = 2;
|
||||
assert(addFortyTwo(y) == 44);
|
||||
assert(@typeOf(addFortyTwo(y)) == i64);
|
||||
assert(@TypeOf(addFortyTwo(y)) == i64);
|
||||
}
|
||||
{#code_end#}
|
||||
|
||||
|
||||
{#header_close#}
|
||||
{#header_open|Function Reflection#}
|
||||
{#code_begin|test#}
|
||||
const assert = @import("std").debug.assert;
|
||||
|
||||
test "fn reflection" {
|
||||
assert(@typeOf(assert).ReturnType == void);
|
||||
assert(@typeOf(assert).is_var_args == false);
|
||||
assert(@TypeOf(assert).ReturnType == void);
|
||||
assert(@TypeOf(assert).is_var_args == false);
|
||||
}
|
||||
{#code_end#}
|
||||
{#header_close#}
|
||||
|
|
@ -4390,10 +4390,10 @@ test "error union" {
|
|||
foo = error.SomeError;
|
||||
|
||||
// Use compile-time reflection to access the payload type of an error union:
|
||||
comptime assert(@typeOf(foo).Payload == i32);
|
||||
comptime assert(@TypeOf(foo).Payload == i32);
|
||||
|
||||
// Use compile-time reflection to access the error set type of an error union:
|
||||
comptime assert(@typeOf(foo).ErrorSet == anyerror);
|
||||
comptime assert(@TypeOf(foo).ErrorSet == anyerror);
|
||||
}
|
||||
{#code_end#}
|
||||
{#header_open|Merging Error Sets#}
|
||||
|
|
@ -4770,7 +4770,7 @@ test "optional type" {
|
|||
foo = 1234;
|
||||
|
||||
// Use compile-time reflection to access the child type of the optional:
|
||||
comptime assert(@typeOf(foo).Child == i32);
|
||||
comptime assert(@TypeOf(foo).Child == i32);
|
||||
}
|
||||
{#code_end#}
|
||||
{#header_close#}
|
||||
|
|
@ -5154,7 +5154,7 @@ test "peer resolve int widening" {
|
|||
var b: i16 = 34;
|
||||
var c = a + b;
|
||||
assert(c == 46);
|
||||
assert(@typeOf(c) == i16);
|
||||
assert(@TypeOf(c) == i16);
|
||||
}
|
||||
|
||||
test "peer resolve arrays of different size to const slice" {
|
||||
|
|
@ -5949,7 +5949,7 @@ pub fn printf(self: *OutStream, arg0: i32, arg1: []const u8) !void {
|
|||
</p>
|
||||
{#code_begin|syntax#}
|
||||
pub fn printValue(self: *OutStream, value: var) !void {
|
||||
const T = @typeOf(value);
|
||||
const T = @TypeOf(value);
|
||||
if (@isInteger(T)) {
|
||||
return self.printInt(T, value);
|
||||
} else if (@isFloat(T)) {
|
||||
|
|
@ -6265,7 +6265,7 @@ test "async function suspend with block" {
|
|||
|
||||
fn testSuspendBlock() void {
|
||||
suspend {
|
||||
comptime assert(@typeOf(@frame()) == *@Frame(testSuspendBlock));
|
||||
comptime assert(@TypeOf(@frame()) == *@Frame(testSuspendBlock));
|
||||
the_frame = @frame();
|
||||
}
|
||||
result = true;
|
||||
|
|
@ -6332,7 +6332,7 @@ test "async and await" {
|
|||
|
||||
fn amain() void {
|
||||
var frame = async func();
|
||||
comptime assert(@typeOf(frame) == @Frame(func));
|
||||
comptime assert(@TypeOf(frame) == @Frame(func));
|
||||
|
||||
const ptr: anyframe->void = &frame;
|
||||
const any_ptr: anyframe = ptr;
|
||||
|
|
@ -6740,7 +6740,7 @@ async fn func(y: *i32) void {
|
|||
Converts a value of one type to another type.
|
||||
</p>
|
||||
<p>
|
||||
Asserts that {#syntax#}@sizeOf(@typeOf(value)) == @sizeOf(DestType){#endsyntax#}.
|
||||
Asserts that {#syntax#}@sizeOf(@TypeOf(value)) == @sizeOf(DestType){#endsyntax#}.
|
||||
</p>
|
||||
<p>
|
||||
Asserts that {#syntax#}@typeId(DestType) != @import("builtin").TypeId.Pointer{#endsyntax#}. Use {#syntax#}@ptrCast{#endsyntax#} or {#syntax#}@intToPtr{#endsyntax#} if you need this.
|
||||
|
|
@ -7045,7 +7045,7 @@ fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_v
|
|||
<p>
|
||||
{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("builtin").AtomicOrder{#endsyntax#}.
|
||||
</p>
|
||||
<p>{#syntax#}@typeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
|
||||
<p>{#syntax#}@TypeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
|
||||
{#see_also|Compile Variables|cmpxchgWeak#}
|
||||
{#header_close#}
|
||||
{#header_open|@cmpxchgWeak#}
|
||||
|
|
@ -7073,7 +7073,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
|
|||
<p>
|
||||
{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("builtin").AtomicOrder{#endsyntax#}.
|
||||
</p>
|
||||
<p>{#syntax#}@typeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
|
||||
<p>{#syntax#}@TypeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
|
||||
{#see_also|Compile Variables|cmpxchgStrong#}
|
||||
{#header_close#}
|
||||
|
||||
|
|
@ -8020,7 +8020,7 @@ test "@setRuntimeSafety" {
|
|||
{#header_close#}
|
||||
|
||||
{#header_open|@splat#}
|
||||
<pre>{#syntax#}@splat(comptime len: u32, scalar: var) @Vector(len, @typeOf(scalar)){#endsyntax#}</pre>
|
||||
<pre>{#syntax#}@splat(comptime len: u32, scalar: var) @Vector(len, @TypeOf(scalar)){#endsyntax#}</pre>
|
||||
<p>
|
||||
Produces a vector of length {#syntax#}len{#endsyntax#} where each element is the value
|
||||
{#syntax#}scalar{#endsyntax#}:
|
||||
|
|
@ -8032,7 +8032,7 @@ const assert = std.debug.assert;
|
|||
test "vector @splat" {
|
||||
const scalar: u32 = 5;
|
||||
const result = @splat(4, scalar);
|
||||
comptime assert(@typeOf(result) == @Vector(4, u32));
|
||||
comptime assert(@TypeOf(result) == @Vector(4, u32));
|
||||
assert(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 }));
|
||||
}
|
||||
{#code_end#}
|
||||
|
|
@ -8250,8 +8250,8 @@ test "integer truncation" {
|
|||
<li>{#link|Pointers#}</li>
|
||||
<li>{#syntax#}comptime_int{#endsyntax#}</li>
|
||||
<li>{#syntax#}comptime_float{#endsyntax#}</li>
|
||||
<li>{#syntax#}@typeOf(undefined){#endsyntax#}</li>
|
||||
<li>{#syntax#}@typeOf(null){#endsyntax#}</li>
|
||||
<li>{#syntax#}@TypeOf(undefined){#endsyntax#}</li>
|
||||
<li>{#syntax#}@TypeOf(null){#endsyntax#}</li>
|
||||
</ul>
|
||||
<p>
|
||||
For these types it is a
|
||||
|
|
@ -8516,20 +8516,20 @@ pub const TypeInfo = union(TypeId) {
|
|||
|
||||
{#header_close#}
|
||||
|
||||
{#header_open|@typeOf#}
|
||||
<pre>{#syntax#}@typeOf(expression) type{#endsyntax#}</pre>
|
||||
{#header_open|@TypeOf#}
|
||||
<pre>{#syntax#}@TypeOf(expression) type{#endsyntax#}</pre>
|
||||
<p>
|
||||
This function returns a compile-time constant, which is the type of the
|
||||
expression passed as an argument. The expression is evaluated.
|
||||
</p>
|
||||
<p>{#syntax#}@typeOf{#endsyntax#} guarantees no run-time side-effects within the expression:</p>
|
||||
<p>{#syntax#}@TypeOf{#endsyntax#} guarantees no run-time side-effects within the expression:</p>
|
||||
{#code_begin|test#}
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
|
||||
test "no runtime side effects" {
|
||||
var data: i32 = 0;
|
||||
const T = @typeOf(foo(i32, &data));
|
||||
const T = @TypeOf(foo(i32, &data));
|
||||
comptime assert(T == i32);
|
||||
assert(data == 0);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user