Binding a function’s void result?

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?

The conversation continues 4

Follow the reasoning

pothos22 Aug Permalink
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.
brin4022 Aug Permalink

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)

brin4022 Aug

Following an earlier reply ↗

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?

pothos22 Aug Permalink
Following an earlier reply ↗

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.

Binding a function’s void result?

The conversation continues 4

Other sides of the same question

How can I subclass a class inside another class?

Comparing have with let bindings in Lean4

TypeScript Map initialization with string array entries