# How to use callbacks with run-time arguments?

**URL:** <https://ziggit.dev/t/how-to-use-callbacks-with-run-time-arguments/2449>\
**Category:** Help\
**Tags:** language\
**Created:** [December 13, 2023, 6:46am UTC](https://ziggit.dev/t/how-to-use-callbacks-with-run-time-arguments/2449 "2023-12-13T06:46:42Z")\
**Posts on this page:** 1\
**Showing post:** 5

<div class="post-metadata">

**Author:** ![Sze](https://ziggit.dev/user_avatar/ziggit.dev/sze/32/496_2.png) [@Sze](https://ziggit.dev/u/Sze)\
**Post date:** [December 13, 2023, 6:33pm UTC](https://ziggit.dev/t/how-to-use-callbacks-with-run-time-arguments/2449/5 "2023-12-13T18:33:05Z")

</div>

I think an important question here is whether the set of possible “callbacks” is closed or open, meaning: “are all the possible kinds of callbacks known at compile time and they only differ by runtime data?”. If that is the case I would ditch the callbacks and use a tagged union instead:

```zig
const std = @import("std");

const Compute = union(enum) {
    found: u8,
    not_found: u8,
    sum_at_least: struct {
        target: usize,
        start: usize = 0,
    },

    fn compute(self: *@This(), r: u8) bool {
        switch (self.*) {
            .found => |f| return f == r,
            .not_found => |n| return n != r,
            .sum_at_least => |*u| {
                u.start += r;
                return u.start >= u.target;
            },
        }
    }
};

fn countUntil(data: []const u8, c: *Compute) usize {
    var index: usize = 0;
    while (index < data.len) {
        const r = data[index];
        if (c.compute(r)) {
            return index;
        }
        index += 1;
    }

    return data.len;
}

pub fn main() !void {
    const seed: u64 = @intCast(std.time.nanoTimestamp());
    std.debug.print("seed: {}\n", .{seed});

    var gen = std.rand.DefaultPrng.init(seed);
    const rng = gen.random();

    const data = "AAAA, world!";
    var c: Compute = switch (rng.uintLessThan(u8, 3)) {
        0 => .{ .found = '!' },
        1 => .{ .not_found = 'A' },
        2 => .{ .sum_at_least = .{ .target = 800 } },
        else => unreachable,
    };
    std.debug.print("compute: {}\n", .{c});

    std.debug.print("{}\n", .{countUntil(data, &c)});
}

```

If the set is open and you need to choose at runtime, you can define an interface that uses type erasure like `std.mem.Allocator` instead of the tagged union.

If the choice can be made at comptime you could use a comptime enum (possibly associated with a runtime payload/tagged union) like here: [Tagged union with comptime tag - #2 by Sze](https://ziggit.dev/t/tagged-union-with-comptime-tag/984/2)

I think the other answers are also valid and useful, I just prefer union if it is enough to do the job. I enjoy that it can be used to basically limit the scope of what needs to be considered, in my example you simply see it takes a `*Compute` you look at compute and can see all the cases, which also makes it easier to evaluate whether `countUntil` works correctly for all cases. With open solutions you don’t get that. So I guess my 2 cents are, don’t use too generic solutions, staying specific has its benefits.

---

_[View the full topic](https://ziggit.dev/t/how-to-use-callbacks-with-run-time-arguments/2449)._
