这怎么能通过？
const std = @import("std");
pub fn main() !void {
const outcome =
std.debug.print("Hello, world\n", .{});
_ = outcome;
}std.debug.print() 的结果是 void，但把结果绑定到 outcome 时，Zig 并不报错。
我在做项目时遇到了这个问题，当时误以为某个第三方库的 API 会返回值，其实并不会。后来用 {s} 把这个结果格式化成字符串时，编译器才报错，但从那里找到最初的错误假设花了些时间。
什么情况下把 void 存进变量会有用？
How is this accepted?
const std = @import("std");
pub fn main() !void {
const outcome =
std.debug.print("Hello, world\n", .{});
_ = outcome;
}The result of std.debug.print() is void, yet binding that result to outcome produces no complaint from Zig.
I encountered this while working on a project, after incorrectly thinking an API from a third-party library produced a value when it actually didn't. Eventually, formatting that result as a string using {s} caused a compiler error, though tracing it back to my initial assumption took some time.
When would storing void in a variable be helpful?
这能简化在 comptime 决定值是否存在的代码。
与其拆解函数类型，还可能要穿过好几层错误联合，不如检查绑定了结果的变量类型，简单得多，这里很有用。
如果函数还做别的事，你可能无论如何都需要调用它。
允许一个除此之外没什么用的值，并没有多大坏处。
It simplifies code in which comptime decides whether there is a value at all.
Rather than picking apart a function's type, potentially through several error unions, checking the type of its bound result is much simpler, and thats useful here.
You may also need the call to happen anyway because it performs other work.
Allowing a value with no other use doesn't cause much trouble.
这些信息不一定存在，因为有些表达式完全不提供这类信息。比如赋值给 _，既不会说明表达式的类型，也不会给结果指定一个具体的内存位置。
Result Location Semantic（https://ziglang.org/documentation/master/#Result-Location-Semantics ）
This information needn't always exist, because certain expressions provide no such information at all: assigning to _, for example, tells you nothing about an expression's type and supplies no particular place in memory where its result belongs.
Result Location Semantic (https://ziglang.org/documentation/master/#Result-Location-Semantics)
我想知道哪些项目需要在 test 块中“丢弃”，又应该在什么时候做？比如 std.zig 模块的源代码末尾有这样的代码。
test {
_ = Ast;
_ = AstRlAnnotate;
_ = BuiltinFn;
_ = Client;
_ = ErrorBundle;
_ = LibCDirs;
_ = LibCInstallation;
_ = Server;
_ = TokenSmith;
_ = WindowsSdk;
_ = number_literal;
_ = primitives;
_ = string_literal;
_ = system;
_ = target;
_ = c_translation;
_ = llvm;
_ = @import("zig/parser_fuzz.zig");
}如果是库，我导入的每个模块都应该放进去吗？如果不是，哪些模块需要这样处理？
I'm wondering which items need “discard”-ing inside a test block, and when? As an example, the end of the std.zig module's source contains this:
test {
_ = Ast;
_ = AstRlAnnotate;
_ = BuiltinFn;
_ = Client;
_ = ErrorBundle;
_ = LibCDirs;
_ = LibCInstallation;
_ = Server;
_ = TokenSmith;
_ = WindowsSdk;
_ = number_literal;
_ = primitives;
_ = string_literal;
_ = system;
_ = target;
_ = c_translation;
_ = llvm;
_ = @import("zig/parser_fuzz.zig");
}For a library, should every module I import go there? Otherwise, which modules need this treatment?
如果是库，我导入的每个模块都应该放进去吗？如果不是，哪些模块需要这样处理？
只有根文件的测试会隐式运行，其他文件/模块/命名空间需要引用包含测试的命名空间。根文件内含有测试的 struct/union/enum 也一样，都需要引用。
说清楚一点，提及 sample.member 只引用 sample.member，并不引用 sample，而 _ = sample 引用的是 sample 本身。
For a library, should every module I import go there? Otherwise, which modules need this treatment?
Tests run implicitly for the root file alone, so with other files/modules/namespaces, the namespace containing those tests must be referenced. That also applies to a struct/union/enum containing tests inside the root file, each needs a reference as well.
For clarity, mentioning sample.member references only sample.member, not sample, while _ = sample references sample itself.
你好， 在一个我无法修改代码的包里，类的层次结构如下。 我想给 Inner 加个方便使用的包装，但因为 Inner 依赖外层实例，目前只做到把它放进外层类的子类里面。 可惜，在多个地方继承 Outer，就意味着每个新子类里都得重复这个方便使用的 ca…
我发现下面两个表达式 以及 行为完全相同。证明定理时也是这样。 它们可以互换吗？区别在哪里？
我在创建一个 Map，其中每个条目都保存字符串数组。怎样在一条语句中同时声明类型并完成初始化？ 我（天真地）这样试了一下。 结果是下面这个错误。
