1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
//
// Struct types are always "anonymous" until we give them a name:
//
// struct {};
//
// So far, we've been giving struct types a name like so:
//
// const Foo = struct {};
//
// * The value of @typeName(Foo) is "<filename>.Foo".
//
// A struct is also given a name when you return it from a
// function:
//
// fn Bar() type {
// return struct {};
// }
//
// const MyBar = Bar(); // store the struct type
// const bar = Bar() {}; // create instance of the struct
//
// * The value of @typeName(Bar()) is "Bar()".
// * The value of @typeName(MyBar) is "Bar()".
// * The value of @typeName(@TypeOf(bar)) is "Bar()".
//
// You can also have completely anonymous structs. The value
// of @typeName(struct {}) is "struct:<position in source>".
//
const print = @import("std").debug.print;
// This function creates a generic data structure by returning an
// anonymous struct type (which will no longer be anonymous AFTER
// it's returned from the function).
fn Circle(comptime T: type) type {
return struct {
center_x: T,
center_y: T,
radius: T,
};
}
pub fn main() void {
//
// See if you can complete these two variable initialization
// expressions to create instances of circle struct types
// which can hold these values:
//
// * circle1 should hold i32 integers
// * circle2 should hold f32 floats
//
var circle1 = ??? {
.center_x = 25,
.center_y = 70,
.radius = 15,
};
var circle2 = ??? {
.center_x = 25.234,
.center_y = 70.999,
.radius = 15.714,
};
print("[{s}: {},{},{}] ", .{
stripFname(@typeName(@TypeOf(circle1))),
circle1.center_x,
circle1.center_y,
circle1.radius,
});
print("[{s}: {d:.1},{d:.1},{d:.1}]\n", .{
stripFname(@typeName(@TypeOf(circle2))),
circle2.center_x,
circle2.center_y,
circle2.radius,
});
}
// Perhaps you remember the "narcissistic fix" for the type name
// in Ex. 065? We're going to do the same thing here: use a hard-
// coded slice to return the type name. That's just so our output
// look prettier. Indulge your vanity. Programmers are beautiful.
fn stripFname(mytype: []const u8) []const u8 {
return mytype[22..];
}
// The above would be an instant red flag in a "real" program.
|
