An imagined comparison starts with a function returning an error union. One version uses try to pass a failure to its caller. The supposedly faster version substitutes catch unreachable. My first suspicion is that the experiment has changed its subject.
The second version asserts that failure cannot occur. If failure does occur, safety-checked builds can crash. It has removed the obligation to return that error, so timing the two spellings would not by itself price equivalent behavior.
I would first compare propagation with an explicit branch that returns the same error. Give both versions identical inputs, payload work, allocation ownership, and caller handling. Separate successful operations from deliberately injected failures, then add a mixed workload with a recorded error frequency. Keep setup outside the timed region unless setup is part of the stated workload. Record compiler version, build mode, target, machine conditions, and enough repeated trials to show variation.
A separate success-only experiment could include catch unreachable if a stated precondition rules out every relevant error for those inputs. Its conclusion would stay within that precondition. Inspecting generated code could help explain a later result, but would not supply one.
That is the comparison I would run. No result yet.
