🚀 go-pugleaf

In article <1990Dec19.222059.6878@mathrt0.math.chalmers.se> augustss@cs.chalmers.se (Lennart Augustsson) writes:
> To see the difference just try to write a function
> that does function composition.

Okay. (What follows isn't tested but you'll get the idea.)

We'll work with a function descriptor type:

  struct basicfun { int (*f)(); } ;
  struct twofun { struct fun *first; struct fun *second; }
  struct fun { int type;
    union { struct basicfun b; struct twofun t; } u;
  } ;
  #define BASICTYPE 1
  #define TWOTYPE 2

To convert a C function pointer into one of these things, given storage
space:

  struct fun *cftofun(c,f)
  int (*c)();
  struct fun *f;
  {
   f->type = BASICTYPE;
   f->u.b.f = c;
   return f;
  }

To call one of these things, given the argument:

  int callfun(f,x)
  struct fun *f;
  int x;
  {
   switch(f->type)
    {
     case BASICTYPE: return f->u.b.f(x);
     case TWOTYPE: return callfun(f->u.t.second,
			          callfun(f->u.t.first,x));
    }
  }

Finally, to answer the question:
  
  struct fun *compose(second,first,f)
  struct fun *second;
  struct fun *first;
  struct fun *f;
  {
   f->type = TWOTYPE;
   f->u.t.first = first;
   f->u.t.second = second;
   return f;
  }

Of course, a more complete implementation would manage struct fun
storage, possibly with garbage collection.

A different strategy is to store basic functions as just pointers, and
composed functions as a pointer to a special function, followed by the
first and second pointers; then pointers to these ``objects'' would be
passed in as arguments.

Back to Lennart:

> I claim that this is impossible to do in a portable way.

You were saying?

---Dan