I have been experimenting with the idea of *function classes* as explained in [this article][1] and Composition applied to function dependencies as described in the following questions:

 - https://stackoverflow.com/questions/58354848/seeking-common-ground-between-object-oriented-structures-and-mathematical-logic
 - https://stackoverflow.com/questions/58571505/evaluating-tree-without-having-to-build-an-interpreter-python

Consider the following *mathematical* functions, where `x` is a variable and `a`, `b` and `c` are constants:

```
f(x) = a*x**2+b*x+c
g(x) = a*sin(3*x)
```

As python function classes these can be expressed as follows:

```
import numpy as np

class F:
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
    def __call__(x):
        return self.a*x**2+self.b*x+self.c

class G:
    def __init__(self, a):
        self.a = a
    def __call__(x):
        return self.a*np.sin(3*x)
```

For several reasons which I prefer not to elaborate here, I prefer to have one meta class which can be instantiated and assigned any function. The difficulty is of course the constants as `self` is undefined outside of a class. Here's what I mean:

```
def f(x):
    return a*x**2+b*x+c

F = FunctionClass(f)
#how to make a, b and c instance variables?
```

If I don't do this I am condemned to writing a class for every function, which defeats the purpose of what I am trying to achieve. I've asked a question addressing this on a more technical level in stack over flow but [it was not very popular at all][2]

Is there a design pattern or python construct that can allow me to achieve this? Perhaps decorators? Perhaps use of the `__dict__` attribute? Any ideas?


  [1]: http://hplgit.github.io/primer.html/doc/pub/class/._class-readable001.html
  [2]: https://stackoverflow.com/questions/60690986/pass-function-to-class-instance-and-modify-how-the-arguments-are-passed-in-the-f