Composite Predicate of function pointers in C - c

Question

I am attempting to build a composite predicate using function pointers.
I dont know if this is possible.
My predicates are of the form: int (*predicate)(int)
Those work fine.
I want to make a function that takes 2 params of type int (*predicate)(int) and returns a function of type int (*predicate)(int), such that the new function returns the value of a(x) && b(x).
I want to make something that works like this:
int ( *composite(int (*a)(int), int (*b)(int)) )(int x) {
return a(x) && b(x);
}
or:
int ( *negate(int (*a)(int)) )(int x) {
return !a(x);
}
I understand that my attempts are returning a value, not a function, but if I try to make another function for them to return, I end up with the exact same problem.
If I do:
int composed(int (*a)(int), int (*b)(int), int x ) {
return a(x) && b(x);
}
It compiles, but then it is no longer of type int (*predicate)(int) so I cannot use it the way that I want to.
How should I go about doing this?
Complete sample code attached for reference:
#include <stdio.h>
unsigned int count(const int* xs, unsigned int len, int (*predicate)(int)) {
int c = 0;
for(int i = 0; i < len; i++) {
if(predicate(xs[i])) c++;
}
return c;
}
int isEven(int x) { return x % 2 == 0; }
int isOdd(int x) { return !isEven(x); }
int isPos(int x) { return x > 0; }
int isNeg(int x) { return x < 0; }
// int composed(int (*a)(int), int (*b)(int), int x ) {
// return a(x) && b(x);
// }
//
// int ( *composite(int (*a)(int), int (*b)(int)) )(int x) {
// return &composed(a,b)(x)
// }
int main() {
int xs[] = {-5,-4,-3,-2,-1,0,1,2,3,4,5};
const int len = 11;
printf("Even: %d\n", count(xs, len, &isEven));
printf(" Odd: %d\n", count(xs, len, &isOdd));
printf(" Pos: %d\n", count(xs, len, &isPos));
printf(" Neg: %d\n", count(xs, len, &isNeg));
// int (*compositePtr)(int) = composite(&isNeg, &isOdd);
// printf("Odd & Neg: %d", count(xs, len, compositePtr));
}

Answer 1

I once wrote the following code for demonstration purposes:
#include <stdio.h>
/* one int for the implicit parameter n,
* one int as return type,
* one int as parameter.
*/
typedef struct int_int_int_closure {
int (*call)(const struct int_int_int_closure *, int);
int n;
} int_int_int_closure;
static int
adderfn(const int_int_int_closure *cl, int n) {
return cl->n + n;
}
int
main(void)
{
int_int_int_closure a3;
a3.call = adderfn;
a3.n = 3;
printf("%d\n", a3.call(&a3, 2));
return 0;
}
You could generalize this code so that the closure consists of a function pointer, a pointer to its data and the size of the data.

Answer 2

You can't dynamically create closures or functions in C, so you need to do something else. The easiest is to use an extra level of indirection. If you change your predicates to
int (**predicate)(void *, int)
which you call as (**predicate)(predicate, x), then you can create new dynamic predicates quite easily:
typedef int (*predicate_t)(void *, int);
struct compose_fn_data {
predicate_t fn, *a, *b;
};
int and_fn(void *data_, int x) {
struct compose_fn_data *data = data_;
return (**data->a)(data->a, x) && (**data->b)(data->b, x);
}
int or_fn(void *data_, int x) {
struct compose_fn_data *data = data_;
return (**data->a)(data->a, x) || (**data->b)(data->b, x);
}
predicate_t *compose(predicate_t fn, predicate_t *a, predicate_t *b) {
struct compose_fn_data *rv = malloc(sizeof *rv);
rv->fn = fn;
rv->a = a;
rv->b = b;
return &rv->fn;
}
predicate_t *and(predicate_t *a, predicate_t *b) { return compose(and_fn, a, b); }
predicate_t *or(predicate_t *a, predicate_t *b) { return compose(or_fn, a, b); }
On minor annoyance with this is that for simple functions, you need to define an additional one-word data structure to hold the function pointer, just to indirect through it. You usually do this with a global next to the function definition:
int isEven_fn(void *data, int x) { (void)data; return x % 2 == 0; }
predicate_t isEven = isEven_fn;
int isOdd_fn(void *data, int x) { return !isEven_fn(data, x); }
predicate_t isOdd = isOdd_fn;
int isPos_fn(void *data, int x) { (void)data; return x > 0; }
predicate_t isPos = isPos_fn;
int isNeg_fn(void *data, int x) { (void)data; return x < 0; }
predicate_t isNeg = isNeg_fn;
Now you can do things like:
printf("Even: %d\n", count(xs, len, &isEven));
printf("Odd & Neg: %d", count(xs, len, and(&isNeg, &isOdd)));
printf("%d", count(xs, len, or(and(&isNeg, &isOdd), &isEven)));
though the latter do leak memory.

Answer 3

When the syntax for passing function pointers to/from functions was invented, I suspect that lots of unmentionable substances were smoked.
Given a function pointer int (*)(int), a function returning such a function pointer is declared as:
int (*func(void))(int);
1 2 3
Where 1 = return type of the function pointer, 2 is the parameter list of the function and 3 = the parameter list of the function pointer.
Now if you want to make a function returning one such pointer, and take two such pointers as parameters, it is trivial:
int (*func(int(*a)(int), int(*b)(int)))(int)
No, it isn't trivial... this is madness! If you can actually write and understand code like this, then it means you have simply worked far too much with C for your own good.
What you absolutely should do instead, is to use a typedef.
typedef int (predicate_t)(int);
...
predicate_t* func (predicate_t* a, predicate_t* b);
However, I suspect that you actually just need a function which returns an integer and not a function pointer.

Answer 4

Here's a block-based implementation of your effort to create compositions of predicate functions:
//
// ViewController.m
// PredicateFunctionsExercise
//
// Created by James Alan Bush on 3/12/22.
//
#import "ViewController.h"
#import simd;
typedef int (^boolean_expression)(void);
typedef int (^guarded_boolean_expression)(void);
typedef int (^ const (*guarded_boolean_expression_t))(void);
typedef int (^(^conditional_boolean_expression)(guarded_boolean_expression_t))(void);
typedef int (^ const (^ const (*conditional_boolean_expression_t))(guarded_boolean_expression_t))(void);
typedef int (^predicate)(void);
typedef int (^ const (*predicate_t))(void);
static int c = 0;
static int flag = (1 << 0);
guarded_boolean_expression flag_conditional = ^ int { return flag; };
conditional_boolean_expression isEven = ^ (guarded_boolean_expression_t _Nullable x) { return ^ int { int result = (*x)() % 2 == 0; printf("%d %s (%d)\t", flag, (result) ? "is even" : "is not even", result); return result; }; };
conditional_boolean_expression isOdd = ^ (guarded_boolean_expression_t _Nullable x) { return ^ int { int result = (*x)() % 2 == 1; printf("%d %s (%d)\t", flag, (result) ? "is odd" : "is not odd", result); return result; }; };
conditional_boolean_expression isPos = ^ (guarded_boolean_expression_t _Nullable x) { return ^ int { int result = (*x)() > 0; printf("%d %s (%d)\t", flag, (result) ? "is positive" : "is not positive", result); return result; }; };
conditional_boolean_expression isNeg = ^ (guarded_boolean_expression_t _Nullable x) { return ^ int { int result = (*x)() < 0; printf("%d %s (%d)\t", flag, (result) ? "is negative" : "is not negative", result); return result; }; };
static void (^evaluate_predicate)(predicate_t) = ^ (predicate_t p) {
printf("\nresult = %d (%d invocations)\n", (*p)(), c);
};
static int (^(^(^g)(__strong conditional_boolean_expression, __strong conditional_boolean_expression, guarded_boolean_expression_t))(int (^__strong)(conditional_boolean_expression_t, conditional_boolean_expression_t, guarded_boolean_expression_t)))(void) =
^ (conditional_boolean_expression boolean_conditional_a, conditional_boolean_expression boolean_conditional_b, guarded_boolean_expression_t guarded_conditional) {
return ^ (int (^bitwise_operation)(conditional_boolean_expression_t, conditional_boolean_expression_t, guarded_boolean_expression_t)) {
return ^ (int boolean_expression) {
return ^ int {
++c;
return boolean_expression;
};
}(bitwise_operation((conditional_boolean_expression_t)&boolean_conditional_a, (conditional_boolean_expression_t)&boolean_conditional_b, guarded_conditional));
};
};
#implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// gbe_a is set to a precalculated and stored result
// Invoking gbe_a() merely returns the results without recalculating it -- perfect for use inside the domain of discourse
guarded_boolean_expression gbe_a = g(isEven, isOdd, &flag_conditional)(^ int (conditional_boolean_expression_t boolean_conditional_a, conditional_boolean_expression_t boolean_conditional_b, guarded_boolean_expression_t guarded_conditional) {
return ((*boolean_conditional_a)(guarded_conditional)() & (*guarded_conditional)()) && (*boolean_conditional_b)(guarded_conditional);
});
guarded_boolean_expression gbe_b = g(isPos, isNeg, &flag_conditional)(^ int (conditional_boolean_expression_t boolean_conditional_a, conditional_boolean_expression_t boolean_conditional_b, guarded_boolean_expression_t guarded_conditional) {
return ((*boolean_conditional_a)(guarded_conditional)() & (*guarded_conditional)()) && (*boolean_conditional_b)(guarded_conditional);
});
// Returning a variety of bitwise operations with randomly chosen operands and operators
// to demonstrate that simd vectors can be used combining multiple bitwise operations into a single operation
simd_uint2 bit_vector = simd_make_uint2((gbe_a() << 0), (gbe_b() << 0));
simd_uint2 bit_mask = simd_make_uint2(flag, flag);
simd_uint2 results = simd_make_uint2(bit_vector & bit_mask);
printf("\n%d & %d == %d\t\t\t", bit_vector[0], bit_mask[0], results[0]);
printf("%d & %d == %d\n", bit_vector[1], bit_mask[1], results[1]);
results = simd_make_uint2(bit_vector | bit_mask);
printf("%d | %d == %d\t\t\t", bit_vector[0], bit_mask[0], results[0]);
printf("%d | %d == %d\n", bit_vector[1], bit_mask[1], results[1]);
results = simd_make_uint2(bit_vector ^ bit_mask);
printf("%d ^ %d == %d\t\t\t", bit_vector[0], bit_mask[0], results[0]);
printf("%d ^ %d == %d\n", bit_vector[1], bit_mask[1], results[1]);
}
#end
The console output: