Functions

Shell

1/1 test "function"... OK
All 1 tests passed.

Function values are like pointers:

test.zig

const assert = @import("std").debug.assert;
comptime {
    assert(@TypeOf(foo) == fn()void);
    assert(@sizeOf(fn()void) == @sizeOf(?fn()void));
}
fn foo() void { }

Shell

Structs, unions, and arrays can sometimes be more efficiently passed as a reference, since a copy could be arbitrarily expensive depending on the size. When these types are passed as parameters, Zig may choose to copy and pass by value, or pass by reference, whichever way Zig decides will be faster. This is made possible, in part, by the fact that parameters are immutable.

pass_by_reference_or_value.zig

    x: i32,
    y: i32,
fn foo(point: Point) i32 {
    // Here, `point` could be a reference, or a copy. The function body
    // can ignore the difference and treat it as a value. Be very careful
    // taking the address of the parameter - it should be treated as if
    // the address will become invalid when the function returns.
    return point.x + point.y;
}
const expect = @import("std").testing.expect;
    try expect(foo(Point{ .x = 1, .y = 2 }) == 3);

Shell

$ zig test pass_by_reference_or_value.zig
1/1 test "pass struct to function"... OK
All 1 tests passed.

For extern functions, Zig follows the C ABI for passing structs and unions by value.

test_fn_type_inference.zig

Shell

$ zig test test_fn_type_inference.zig
1/1 test "fn type inference"... OK
All 1 tests passed.

test_fn_reflection.zig

const expect = @import("std").testing.expect;
test "fn reflection" {
    try expect(@typeInfo(@TypeOf(expect)).Fn.args[0].arg_type.? == bool);
    try expect(@typeInfo(@TypeOf(expect)).Fn.is_var_args == false);
}

Shell