## Higher order functions in C?

Posted: Jun 10, 2012, 10:01The Structure and Interpretation of Computer Programs course has a class on higher order functions, which is the ability of a function to accept a function and/or returns another function that uses the input function. The C programming language has very limit capability to do this and it is limited to being able to accept function pointers or return function pointers. I wanted to explore this limitation further to figure out exactly how far I can stretch this, so I wrote a small C program that tries to emulate this concept. This is just random tinkering, so if the reader is looking for a specific lesson, then let me clarify that there is none.

I wrote a program to get square roots using the Newton-Raphson method -- the same one that was used in the course with an attempt to keep the structure as close as possible to the scheme example in the class video. The Lisp-based listing for the course can be found on the internet and here is what I wrote:

#include <stdio.h> #include <stdlib.h> typedef double (*generic_func_t) (double); #define dx 0.000001 #define absolute(n) ((n) < 0 ? -(n) : (n)) generic_func_t deriv(generic_func_t f) { double deriv_func(double x) { return (f(x + dx) - f(x)) / dx; } return deriv_func; } double fixed_point(generic_func_t f, double x) { while (absolute(f(x) - x) > dx) x = f(x); return f(x); } double newton(generic_func_t f, double guess) { double newton_func(double y) { generic_func_t df = deriv(f); return (y - f(y) / df (y)); } return fixed_point(newton_func, guess); } double sqrt(double x) { double sqrt_func(double y) { return (x - y*y); } return newton(sqrt_func, 1); } int main(int argc, char **argv) { if (argc < 2) { printf(“Usage: %s <number>\n”, argv[0]); exit (1); } printf (“%lf\n”, sqrt(strtod(argv[1], NULL))); return 0; }The first thing that is evident in the above is that the syntax is non-standard. I have declared some functions within another function and that is not allowed by the C standard. GCC however implements this concept of nested functions as an extension, so this compiled cleanly for me. Running this however is a completely different thing.

Executing the above program for any argument results in segfaults and analysis of the program under gdb shows that the generated code is quite ridiculous. This is expected however, since we have pushed the gcc nested function support too far. The nested functions within gcc are OK as long as they remain within the following limits:

- They are only used within the function that nests them, either directly or indirectly via some function calls. Essentially, control from the nested function should return before it’s nesting function returns.
- If they’re used outside the nesting function and called after the nesting function returns, then they don’t use any local variables or arguments of the nesting function

*sqrt_func*,

*newton_func*and

*deriv_func*are the nested functions. Of these however, only

*deriv_func*is actually returned as a function to be used from within

*newton_func*. This is wrong because it breaks (2).

*deriv_func*uses the input argument

*f(x)*which is essentially

*sqrt_func*and is actually called after the

*deriv()*function returns. Other than that however, all of our ‘functional-type’ code looks sane and within what is supported by gcc.

So I modified the deriv function and came up with the listing below:

#include <stdio.h> #include <stdlib.h> typedef double (*generic_func_t) (double); #define dx 0.000001 #define absolute(n) ((n) < 0 ? -(n) : (n))The only change above is that instead of accepting a function and returning another indouble deriv(double x, generic_func_t f){return (f(x + dx) - f(x)) / dx;}double fixed_point(generic_func_t f, double x) { while (absolute(f(x) - x) > dx) x = f(x); return f(x); } double newton(generic_func_t f, double guess) { double newton_func(double y) {double dy = deriv(y, f);return (y - f(y) / dy); } return fixed_point(newton_func, guess); } double sqrt(double x) { double sqrt_func(double y) { return (x - y*y); } return newton(sqrt_func, 1); } int main(int argc, char **argv) { if (argc < 2) { printf(“Usage: %s <number>\n”, argv[0]); exit (1); } printf (“%lf\n”, sqrt(strtod(argv[1], NULL))); return 0; }

*deriv*, I now accept a function and return the evaluation of the derived function for the specified value. This is highlighted in bold above. This program now builds with gcc and also runs correctly. It should similarly be possible to eliminate the other nested functions to get a much more compact and standards-compliant program.