Best pattern for callback parametrization

[Sze]

There is also std.mem.sortContext which is (currently) implemented via std.sort.insertionContext:

context must have methods swap and lessThan

I think std.sort is a simpler interface, while std.sortContext allows you to not only define the comparison function but also how the swap function works (which is useful when the default swap function std.mem.swap doesn’t work for what you consider to be the “element” while sorting.

Here is an example where I use a custom swap function to sort rows of a matrix that is stored as a flat slice in memory:

Sort function for chunks of a slice

You can do it by using a Context object with pdqContext (or other sort functions of the *Context variant), it allows you to map the usize a and b indexes, which are passed to the lessThan and swap functions, in a way where these indexes represent the row that is currently being sorted. const std = @import("std"); fn sort(matrix: []f32, n: usize) void { const Context = struct { items: []f32, columns: usize, pub fn lessThan(ctx: @This(), a: usize, b: usize) bool { …

I think the “context with multiple methods” pattern makes sense, when you have multiple methods that need to work together and I see the “provide a single callback function” more as the special case of that when you only need a single function.