How to handle function pointers with unknown signature?

Help
1

Hello everybody,

I’m currently working on an CLI application where I display a series of screens containing several candidates you can choose from. Like that :

> Create new tag
  Existing tags
  View timeline

I have a struct for the candidates containing the associated name and a function pointer to the function that needs to be triggered when that candidate is selected :

pub const FuzzyFinderCandidate = struct {
    name: []const u8,
    function: *const fn () void,
};

And then there is a struct for each screen where I have a list of FuzzyFinderCandidate and the functions that need to be called according to the selected candidate :

pub const OperationScreen = struct {
    // this is the struct that will actually handle the list of candidates
    ff: FuzzyFinder = FuzzyFinder{},

    pub fn init(self: *OperationScreen) !void {
        var candidates = [_]FuzzyFinderCandidate{
            .{ .name = "Create new tag", .function = goToCreateNewTagScreen },
            .{ .name = "Existing tags", .function = goToExistingTagsScreen },
            .{ .name = "View timeline", .function = goToViewTimelineScreen },
        };
        try self.ff.setCandidates(&candidates);
    }

    pub fn goToCreateScreen() void {
        printer.print("Should go to tag creation screen\n", .{});
    }

    pub fn goToExistingTagsScreen() void {
        printer.print("should go to existing tags screen\n", .{});
    }

    pub fn goToViewTimelineScreen() void {
        printer.print("should go to view timeline screen\n", .{});
    }
};

So far it works perfectly but the problem appears when I want to change the signature of the “callback functions”. For example to be able to access the fields of the screen struct :

pub fn goToExistingTagsScreen(self: *OperationScreen) void {
    // need to do some stuff that require access to `self`
}

The function pointer in FuzzyFinderCandidate now has an incorrect function signature and I’m not sure how to handle the situation since the signature will change with each different “screen” struct.

I could make a different type of “candidate” struct for each screen but it would only move the problem since the list of candidates is actually handled by the FuzzyFinder struct that is the same for all the different screens.

The only solution I found was to make use of anytype on the function pointer. But that is not an option anymore since anytype struct fields have been removed from the language.

It seems that the opaque type could help with this situation but honestly I struggle to really understand how that works.

Any idea on the best way to handle this situation?

2

Yes, you can use * anyopaque.

pub const FuzzyFinderCandidate = struct {
    name: []const u8,
    function: *const fn (*anyopaque) void,
};

There is no change when callling (you can pass any pointer to the function).
There is a change in the implementation:

pub fn goToExistingTagsScreen(ptr: *anyopaque) void {
    // need to do some stuff that require access to `self`
    const self: *OperationScreen = @ptrCast(@alignCast(ptr));
}
2 Likes
3

Thanks a lot it works perfectly :slight_smile:

The final implementation looks like this:

pub const FuzzyFinderCandidate = struct {
    name: []const u8,
    function: *const fn (*anyopaque) void,
    function_struct: *anyopaque,
};

pub const OperationScreen = struct {
    ff: FuzzyFinder = FuzzyFinder{},

    pub fn init(self: *OperationScreen, ptrTh: *TerminalHandler) !void {
        var candidates = [_]FuzzyFinderCandidate{
            .{ .name = "Create new tag", .function = goToCreateScreen, .function_struct = self },
            .{ .name = "Existing tags", .function = goToExistingTagsScreen, .function_struct = self },
            .{ .name = "View timeline", .function = goToCreateScreen, .function_struct = self },
        };
        try self.ff.setCandidates(&candidates);
    }

    pub fn goToExistingTagsScreen(ptr: *anyopaque) void {
        const self: *OperationScreen = @ptrCast(@alignCast(ptr));
        // do stuff with `self` here
    }
};

And somewhere inside the FuzzyFinder struct I call the function of the candidate with the associated pointer to the screen struct:

candidate.function(candidate.function_struct);

Thanks again :slight_smile:

2 Likes
4

It’s worth pointing out that there are simpler solutions to this problem domain, which you should prefer if you can.

Dispatching on runtime function pointers has one advantage, it’s “open world”. So for instance, if you need to provide user-code-configurable behaviors, you might want to do it this way.

But if it’s just choosing between some options, you may be happier with a tagged union:

pub const FuzzyFinderCandidate = union(enum) {
    @"Create new tag": CreateTagPayload,
    @"Existing tags": ExistingTagsPayload,
    @"View Timeline": ViewTimelinePayload,

    pub fn dispatch(ffc: FuzzyFinderCandidate) T {
          return switch(ffc) {
                /// Handle payload specifics here
          };
    }
};

Type erasure (the strategy you’re pursuing) has disadvantages, and should not be the first resort for this kind of domain.

8 Likes