Functions, pointers, nested functions, clojures

While ago GCC introduced nested functions which are allowing easy solution of funargs problem. With funargs problem solved C can accommodate closures and provide everything what different modern languages can, except funny syntax. In order to demonstrate that we need function pointers and they are not part of modern languages derived from C. So, we start with function pointers refresher.

Function pointers

They are more cryptic than other pointers and they scare away younger generations of programmers. We will declare function and pointer to it:

int add( int i, int j) { return i + j; } int main(){ int (*fptr)(int,int) = add; printf("%d\n", fptr(2, 3)); return 0; }

We have return type, variable name in brackets and type list for parameters. We could also use address of operator during assignment. How we pass it as parameter?

int execute(int (*fptr)(int,int), int a, int b) { return fptr(a, b); } printf("%d\n", execute(fptr, 2, 3));

How we return it, write function which is returning function pointer? There is user friendly way, we declare typedef for function pointer:

typedef int (*fptra)(int,int); fptra get() { return add; } printf("%d\n", get()(2, 3));

But there is also user unfriendly way:

int (*fptr2fptr())(int, int) { return add; } int (*fptr)(int,int) = fptr2fptr(); printf("%d\n", fptr(2, 3)); printf("%d\n", (*fptr2fptr())(2, 2));

Return type of return type goes in front, inside first pair of brackets name and own parameters, inside the second pair of brackets list of parameter types of return type. And just for those who value extreme programming above all, pointer to function which returns function which returns function:

int (*(*f2f2f())(void))(int,int){ return fptr2fptr; } int (*(*f2f)())(int,int) = f2f2f(); int (*fadd)(int,int) = f2f(); printf("%d\n",fadd(4, 3));

Nested Functions

Those are GCC specifics and they are just ordinary functions but inside another function. Standard C will not let you define function within function. To demonstrate we can do trampolining of one notoriously recursive function.

int factorial(int i){ int acc = 1; void * f() { if (i < 2) return 0; acc *= i; --i; return f; } while(f()) continue; return acc; } int main() { int i; for(i = 2; i < 14; i++) printf("%d! is %d\n", i, factorial(i)); return 0; }

Here nested function is accessing variables which are host scoped and returns self or NULL. We got whole function back but we are not really using it, except to exit while loop if it is NULL. To remedy that we will dispatch those nested functions out of host function.

struct closure{ int counter; int visited; } data; int (*pgen(int i))(int){ int increase(int k){ data.counter += k; data.visited++; return data.counter; } int decrease(int k){ data.counter -= k; data.visited++; return data.counter; } if(i) return increase; return decrease; } int main(){ data.counter = 4; data.visited = 4; int (*incr)(int) = (*pgen)(1); int (*decr)(int) = (*pgen)(0); printf("counter = %d visited = %d\n", data.counter, data.visited); printf("counter = %d\n", incr(2)); printf("counter = %d\n", decr(1)); printf("counter = %d visited = %d\n", data.counter, data.visited); printf("counter = %d\n", incr(4)); printf("counter = %d\n", decr(1)); printf("counter = %d visited = %d\n", data.counter, data.visited); return 0; }

Here we have struct which is global variable, it is not really closure but just named like that, and one function generator. If we pass zero to generator we get one function back and for non zero the other one. Both nested functions now operating on global variable. In previous example we were working on variables belonging to host function, in this case if we try the same we will have problems since host's variables went out of scope.

Funarg problem

This one is related to functional languages and nested functions. If we pass nested function as argument to another function that is called downward funarg problem. Returning nested function to caller is upwards funarg problem. If any of passed or returned functions references variable from scope of declarer, those must be available to nested function so it can be executed. Passing nested function as argument to another function is not problem in C since all local variables of declarer are alive.

void execute(void(*fptr)(int), int i){ fptr(i); } void print(int(*fptr)(void)){ printf("counter = %d\n", fptr()); } int main(){ int counter = 0; void increase(int k){ counter += k; } void decrease(int k){ counter -= k; } int getter(){ return counter; } execute(increase, 3); print(getter); execute(decrease, 2); print(getter); return 0; }

Returning nested function is more problematic because declarer went out of scope. That could be addressed like in Java, if anonymous function uses some declarer's variable, that variable must be final. In C there is even more options, we can use static variables or allocate them on the heap.

int (*pgen(int i))(int){ static int counter = 0; int increase(int k){ counter += k; return counter; } int decrease(int k){ counter -= k; return counter; } if(i) return increase; return decrease; } int main(){ int (*incr)(int) = (*pgen)(1); int (*decr)(int) = (*pgen)(0); printf("counter = %d\n", incr(2)); printf("counter = %d\n", decr(1)); printf("counter = %d\n", incr(4)); printf("counter = %d\n", decr(1)); return 0; }

It is easier to use static than malloc and free. Removing static from counter declaration will result in exception during execution of program. So, funargs problem is not problem for C in GCC version. This makes C almost functional language, functional with few extras.