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

Function values are like pointers:

test.zig

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

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.

test.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;
    expect(foo(Point{ .x = 1, .y = 2 }) == 3);

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

Function parameters can be declared with anytype in place of the type. In this case the parameter types will be inferred when the function is called. Use @TypeOf and to get information about the inferred type.

test.zig

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

const expect = @import("std").testing.expect;
test "fn reflection" {
    expect(@typeInfo(@TypeOf(expect)).Fn.return_type.? == void);
    expect(@typeInfo(@TypeOf(expect)).Fn.is_var_args == false);
}