Abgeleitete Fehlermengen

Naming every error a function might return can be a chore, especially when it calls other fallible functions. Zig can infer the set.

Write just !T with nothing before the bang. Zig studies the function body and figures out every error it can produce.

Each try and each returned error inside the body is gathered automatically into one inferred error set for that function.

Add a new failing call later and the inferred set grows to include it. You never forget to update a hand-written list.

If your function uses try on another fallible call, that callee's possible errors are folded into your inferred set as well.

Sometimes you want a fixed public contract. Naming the set before ! forbids any error outside it, which inference will not do.

Inferred sets are convenient and self-updating; explicit sets are precise and stable. Pick by whether the contract must stay frozen.

You can still reason about errors at runtime. In debug builds Zig keeps an error return trace showing where a failure began.

Inference shines on private helper functions where a strict public API is not needed. Let Zig handle the bookkeeping there.

Inferred or explicit, every error must still be handled by callers. Inference saves typing, not safety; the compiler stays strict.

Many Zig functions simply use !T and let inference work. Reserve named sets for the boundaries you want to lock down.

A function is declared with the return type !u32 and no error set before the bang. What does Zig do?

You saw inferred error sets via bare !T, how they grow with the body, and when an explicit set is the better choice. ✅