From 30715560c829d5636734edf7eabff3ee4d170e5d Mon Sep 17 00:00:00 2001 From: Robin Voetter Date: Mon, 9 Dec 2019 21:59:42 +0100 Subject: [PATCH] Rename @typeOf to @TypeOf in the language reference --- doc/langref.html.in | 104 ++++++++++++++++++++++---------------------- 1 file changed, 52 insertions(+), 52 deletions(-) diff --git a/doc/langref.html.in b/doc/langref.html.in index e51e59d562..fe015de733 100644 --- a/doc/langref.html.in +++ b/doc/langref.html.in @@ -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#}

@@ -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" {

{#header_close#} {#header_open|Function Parameter Type Inference#} -

- Function parameters can be declared with {#syntax#}var{#endsyntax#} in place of the type. +

+ 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.

{#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 {

{#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.

- Asserts that {#syntax#}@sizeOf(@typeOf(value)) == @sizeOf(DestType){#endsyntax#}. + Asserts that {#syntax#}@sizeOf(@TypeOf(value)) == @sizeOf(DestType){#endsyntax#}.

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

{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("builtin").AtomicOrder{#endsyntax#}.

-

{#syntax#}@typeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}

+

{#syntax#}@TypeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}

{#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

{#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("builtin").AtomicOrder{#endsyntax#}.

-

{#syntax#}@typeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}

+

{#syntax#}@TypeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}

{#see_also|Compile Variables|cmpxchgStrong#} {#header_close#} @@ -8020,7 +8020,7 @@ test "@setRuntimeSafety" { {#header_close#} {#header_open|@splat#} - 
{#syntax#}@splat(comptime len: u32, scalar: var) @Vector(len, @typeOf(scalar)){#endsyntax#}
+ 
{#syntax#}@splat(comptime len: u32, scalar: var) @Vector(len, @TypeOf(scalar)){#endsyntax#}

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" {

  • {#link|Pointers#}
  • {#syntax#}comptime_int{#endsyntax#}
  • {#syntax#}comptime_float{#endsyntax#}
    • -
  • {#syntax#}@typeOf(undefined){#endsyntax#}
    • -
  • {#syntax#}@typeOf(null){#endsyntax#}
    • +
  • {#syntax#}@TypeOf(undefined){#endsyntax#}
    • +
  • {#syntax#}@TypeOf(null){#endsyntax#}

    • For these types it is a @@ -8516,20 +8516,20 @@ pub const TypeInfo = union(TypeId) { {#header_close#} - {#header_open|@typeOf#} - 

    {#syntax#}@typeOf(expression) type{#endsyntax#}
    + {#header_open|@TypeOf#} + 
    {#syntax#}@TypeOf(expression) type{#endsyntax#}

    This function returns a compile-time constant, which is the type of the expression passed as an argument. The expression is evaluated.

    -

    {#syntax#}@typeOf{#endsyntax#} guarantees no run-time side-effects within the expression:

    +

    {#syntax#}@TypeOf{#endsyntax#} guarantees no run-time side-effects within the expression:

    {#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); }